diff --git a/docs-translations/pt-BR/tutorial/quick-start.md b/docs-translations/pt-BR/tutorial/quick-start.md
index f9883144c825..eecf67878fc4 100644
--- a/docs-translations/pt-BR/tutorial/quick-start.md
+++ b/docs-translations/pt-BR/tutorial/quick-start.md
@@ -4,7 +4,7 @@ Electron permite criar aplicações desktop com puro JavaScript através de
 um runtime com APIs ricas e nativas. Você pode ver isso como uma variação do
 runtime do io.js que é focado em aplicações desktop em vez de web servers.
 
-Isso não significa que o Electron é uma ligação em JavaScript para blibliotécas
+Isso não significa que o Electron é uma ligação em JavaScript para bibliotecas
 de interface gráfica (GUI). Em vez disso, Electron usa páginas web como
 interface gráfica, então você pode ver isso também como um navegador Chromium
 mínimo, controlado por JavaScript.
@@ -17,13 +17,13 @@ mostrar uma GUI criando páginas web.
 
 ### Processo Renderizador
 
-Desde que o Electron usa o Chromium para mostrar as páginas web, a arquitetura
+Já que o Electron usa o Chromium para mostrar as páginas web, a arquitetura
 multi-processo do Chromium também é usada. Cada página web no Electron roda em
 seu próprio processo, o que é chamado de __processo renderizador__.
 
 Em navegadores comuns, as páginas web normalmente rodam em um ambiente em sandbox
-e não tem permissão de acesso para recursos nativos. Usuários Electron, entretanto,
-tem o poder de usar as APIs do io.js nas páginas web, permitindo interações de baixo
+e não têm permissão de acesso para recursos nativos. Usuários Electron, entretanto,
+têm o poder de usar as APIs do io.js nas páginas web, permitindo interações de baixo
 nível no sistema operacional.
 
 ### Diferenças Entre o Processo Principal e o Processo Renderizador
@@ -33,12 +33,12 @@ Cada instância de `BrowserWindow` roda a página web em seu próprio processo r
 Quando uma instância de `BrowserWindow` é destruída, o processo renderizador
 correspondente também é finalizado.
 
-O processo principal gerência todas as páginas web de seus processos renderizadores
+O processo principal gerencia todas as páginas web de seus processos renderizadores
 correspondentes. Cada processo renderizador é isolado e toma conta de sua
 respectiva página web.
 
 Nas páginas web, chamar APIs nativas relacionadas à GUI não é permitido porque
-gerênciar recursos de GUI em páginas web é muito perigoso e torna fácil o vazamento de
+gerenciar recursos de GUI em páginas web é muito perigoso e torna fácil o vazamento de
 recursos. Se você quer realizar operações com GUI em páginas web, o processo
 renderizador da página web deve se comunicar com o processo principal para requisitar
 que o processo principal realize estas operações.
@@ -52,26 +52,26 @@ módulo [remoto](../../../docs/api/remote.md) para comunicação RPC.
 Geralmente, um app Electron é estruturado assim:
 
 ```text
-your-app/
+seu-app/
 ├── package.json
 ├── main.js
 └── index.html
 ```
 
-O formato de `package.json` é exatamente o mesmo que os dos módulos do Node, e
+O formato de `package.json` é exatamente o mesmo que o dos módulos do Node,
 e o script especificado pelo campo `main` é o script de inicialização do seu app,
 que irá executar o processo principal. Um exemplo do seu `package.json` deve parecer
 com isso:
 
 ```json
 {
-  "name"    : "your-app",
+  "name"    : "seu-app",
   "version" : "0.1.0",
   "main"    : "main.js"
 }
 ```
 
-__Nota__: Se o campo `main` não estiver presente no `package.jso`, o Electron irá
+__Nota__: Se o campo `main` não estiver presente no `package.json`, o Electron irá
 tentar carregar um `index.js`
 
 O `main.js` deve criar as janelas e os manipuladores de eventos do sistema, um típico
@@ -140,8 +140,8 @@ Finalmente o `index.html` é a página web que você quer mostrar:
 
 ## Execute seu App
 
-Uma vez que você criou seus arquivos `main.js`, `index.html, e `package.json` iniciais,
-você provavelmente vai querer tentar executar seu app localmente para testa-lo a ter
+Uma vez que você criou seus arquivos `main.js`, `index.html`, e `package.json` iniciais,
+você provavelmente vai querer tentar executar seu app localmente para testa-lo e ter
 certeza que funciona como você espera.
 
 ### electron-prebuilt
@@ -167,19 +167,19 @@ executar seu app diretamente.
 #### Windows
 
 ```bash
-$ .\electron\electron.exe your-app\
+$ .\electron\electron.exe seu-app\
 ```
 
 #### Linux
 
 ```bash
-$ ./electron/electron your-app/
+$ ./electron/electron seu-app/
 ```
 
 #### OS X
 
 ```bash
-$ ./Electron.app/Contents/MacOS/Electron your-app/
+$ ./Electron.app/Contents/MacOS/Electron seu-app/
 ```
 
 `Electron.app` aqui é uma parte do pacote de lançamento do Electron, você pode baixa-lo
@@ -188,5 +188,5 @@ $ ./Electron.app/Contents/MacOS/Electron your-app/
 ### Executar como uma distribuição
 
 Depois de terminar seu app, você pode criar uma distribuição seguindo o guia
-[Application Distribution](./application-distribution.md) e então executar o app
+[Distribuição de aplicações](./application-distribution.md) e então executar o app
 empacotado.