diff --git a/de-DE/community.md b/de-DE/community.md
index bb56091f3..6c6fb2b86 100644
--- a/de-DE/community.md
+++ b/de-DE/community.md
@@ -59,6 +59,7 @@ Das Entwicklerteam von Rust koordiniert sich in [#rust-internals][internals_irc]
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [Rust中文][cn_org] Rust 语言中文 Chat 社区(非IRC频道)
### Teamkanäle (Englisch)
diff --git a/en-US/community.md b/en-US/community.md
index 8124207b1..38fdefb37 100644
--- a/en-US/community.md
+++ b/en-US/community.md
@@ -81,6 +81,7 @@ to ask questions about contributing to Rust.
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [Rust中文][cn_org] Rust 语言中文 Chat 社区(非IRC频道)
### Team channels
diff --git a/es-ES/community.md b/es-ES/community.md
index 961642305..da1bbfec9 100644
--- a/es-ES/community.md
+++ b/es-ES/community.md
@@ -85,6 +85,7 @@ adecuado para preguntas sobre como contribuir con Rust.
- [#rust-de][de_irc] ist für die allgemeine Diskussion über Rust auf Deutsch
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
### Canales de temas específicos
diff --git a/fr-FR/community.md b/fr-FR/community.md
index 6a6127c56..b13e678b0 100644
--- a/fr-FR/community.md
+++ b/fr-FR/community.md
@@ -64,6 +64,7 @@ Les développeurs de Rust échangent sur [#rust-internals][internals_irc]. Ce ca
- [#rust-de][de_irc] ist für die allgemeine Diskussion über Rust auf Deutsch
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
### Les canaux thématiques
diff --git a/id-ID/community.md b/id-ID/community.md
index 3a0311192..a8c454da2 100644
--- a/id-ID/community.md
+++ b/id-ID/community.md
@@ -71,6 +71,7 @@ mengajukan pertanyaan tentang berkontribusi pada Rust.
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [Rust中文][cn_org] Rust 语言中文 Chat 社区(非IRC频道)
### Saluran Tim
diff --git a/it-IT/community.md b/it-IT/community.md
index c43e6e236..f2f5979a1 100644
--- a/it-IT/community.md
+++ b/it-IT/community.md
@@ -85,6 +85,7 @@ Gli sviluppatori di Rust si organizzano su [#rust-internals][internals_irc]. Ded
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
### Canali specifici
diff --git a/ja-JP/community.md b/ja-JP/community.md
index 03d9e194a..010d3b3fc 100644
--- a/ja-JP/community.md
+++ b/ja-JP/community.md
@@ -71,6 +71,7 @@ Rust自体の開発についてリアルタイムで議論するための場で
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
### トピック別チャネル
diff --git a/ko-KR/community.md b/ko-KR/community.md
index 4e880dafa..b9014d01a 100644
--- a/ko-KR/community.md
+++ b/ko-KR/community.md
@@ -68,6 +68,7 @@ Rust에 기여하는 데 대한 질문을 하는 데도 쓰입니다.
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
- [Rust中文][cn_org] Rust 语言中文 Chat 社区(非IRC频道)
### 팀 채널
diff --git a/pl-PL/community.md b/pl-PL/community.md
index 4e285a32a..f94fc6ab2 100644
--- a/pl-PL/community.md
+++ b/pl-PL/community.md
@@ -85,6 +85,7 @@ Służy także do zadawania pytań o sposoby zaangażowania się w rozwój Rusta
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
### Kanały tematyczne
diff --git a/pt-BR/community.md b/pt-BR/community.md
index 9c1bc6be5..8038b9538 100644
--- a/pt-BR/community.md
+++ b/pt-BR/community.md
@@ -83,6 +83,7 @@ perguntar questões sobre contribuir para o Rust.
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
### Canais sobre tópicos
diff --git a/ru-RU/community.md b/ru-RU/community.md
index 6d6a6dbd6..bf62a33f5 100644
--- a/ru-RU/community.md
+++ b/ru-RU/community.md
@@ -81,6 +81,7 @@ title: Сообщество Rust · Язык Программирован
- [#rust-es][es_irc] es para una discusión general sobre Rust en español
- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
### Тематические каналы (англ.)
diff --git a/sv-SE/community.md b/sv-SE/community.md
new file mode 100644
index 000000000..0d9819094
--- /dev/null
+++ b/sv-SE/community.md
@@ -0,0 +1,282 @@
+---
+layout: sv-SE/default
+title: Rust-communityt · Programmeringsspråket Rust
+---
+
+# Rust-communityt
+
+Programmeringsspråket rust har många kvalitéter, men språkets
+största styrka är den gemenskap av människor som samlas för att
+se att användning av språket är en givande upplevelse.
+
+Vi är hängivna till och ämnar att tillhandahålla en vänlig, säker
+och välkomnande miljö för alla, oavsett könsidentitet, sexuell läggning,
+funktionshinder, etnicitet, religion eller liknande personliga
+drag. Vår [uppförandekod][coc] sätter standarden för hur man beter
+sig i alla rusts officiella forum.
+
+Om du känner att du har blivit eller är trakasserad av eller
+obehagligt bemött av någon i communityt, [kontakta][mod_team_email]
+då någon i [rusts modereringsteam][mod_team] omgående. Oavsett om
+du bidrar ofta eller är ny till språket bryr vi oss om att göra
+communityt en säker plats för dig.
+
+[coc]: conduct.html
+[mod_team_email]: mailto:rust-mods@rust-lang.org
+
+## Att komma igång
+
+Den viktigaste resurserna communityt har att erbjuda för de som
+är nya till språket rust är:
+
+- [#rust-beginners][beginners_irc], en IRC-kanal som gillar att
+ svara på frågor oavsett djup.
+- [Användarnas forum][users_forum], för allmän diskussion om Rust.
+
+Du kan också hitta hjälp på fråge-och-svar-siten [Stack Overflow][stack_overflow].
+
+[stack_overflow]: https://stackoverflow.com/questions/tagged/rust
+
+## Nyheter
+
+[Den Här Veckan i Rust][twir] samlar alla senaste nyheter, kommande
+evenemang och en veckovis redogörelse av alla förändringar i språket Rust
+och bibliotek för Rust. [Rustbloggen][rust_blog] är stället där Rust-teamet
+annoncerar om större förändringar. Och nästan allt som händer kring Rust
+diskuteras på den inofficiella subredditen [/r/rust][reddit].
+
+Vi har också ett [twitterkonto][twitter]. Om du inte kan läsa engelska kan
+du också följa vår [Weibo][weibo] på kinesiska.
+
+[twir]: https://this-week-in-rust.org/
+[rust_blog]: http://blog.rust-lang.org/
+[reddit]: https://www.reddit.com/r/rust
+[reddit_coc]: https://www.reddit.com/r/rust/comments/2rvrzx/our_code_of_conduct_please_read/
+[twitter]: https://twitter.com/rustlang
+[weibo]: http://weibo.com/u/5616913483
+
+## IRC-kanaler
+
+"Rustaceans" (de som deltar i rust-communityt) tillhandahåller ett antal
+vänliga och högtraffikerade [IRC]-kanaler på Mozillas IRC-nätverk,
+irc.mozilla.org.
+
+[#rust][rust_irc] kanalen är en plats för generell diskussion om rust och
+ett bra ställe att att fråga om hjälp. Där finner du folk som är villiga
+att svara alla sorts frågor om rust. Vanligtvis får du svar snabbt.
+
+Rusts utvecklare koordinerar i kanalen [#rust-internals][internals_irc].
+Den är för realtidsdiskussion om utveckling av språket rust självt.
+Kanalen är också rätt plats för frågor om att bidra till rust.
+
+### Huvudkanaler
+
+- [#rust][rust_irc] är en allmän kanal för Rust-relaterat
+- [#rust-beginners][beginners_irc] är ett ställe för de som är nya till språket
+och har lägre traffik än #rust
+- [#rust-internals][internals_irc] är för diskussion om arbete för och på
+Rust-projektet självt.
+
+### Internationella kanaler
+
+- [#rust-br][br_irc] é dedicado à discussão sobre Rust no Brasil
+- [#rust-de][de_irc] ist für die allgemeine Diskussion über Rust auf Deutsch
+- [#rust-es][es_irc] es para una discusión general sobre Rust en español
+- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
+- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+- [#rust-sv](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sv) är för allmän diskussion om Rust på svenska
+- [Rust中文][cn_org] Rust 语言中文 Chat 社区(非IRC频道)
+
+### Team-kanaler
+
+- [#cargo][cargo_irc] är för diskussion om Cargo, rusts pakethanterare och [cargo teamets][cargo_team] hemvist
+- [#rust-community][community_irc] är [community teamets][community_team] hemvist
+- [#rustc][rustc_irc] är [kompilatorteamets][compiler_team] hemvist
+- [#rust-dev-tools][dev_tools_irc] är [utvecklarverktygsteamets][dev_tools_team] hemvist
+- [#rust-docs][docs_irc] är [dokumentationsteamets][doc_team] hemvist
+- [#rust-infra][infra_irc] är [infrastruktur-teamets][infra_team] hemvist
+- [#rust-lang][lang_irc] är [språkteamets][language_team] hemvist
+- [#rust-libs][libs_irc] är [biblioteksteamets][library_team] hemvist
+- [#rust-mods][mod_irc] är irc-kanalen för [moderationsteamet][mod_team]
+- [#rust-style][style_irc] är [stil-guide-fixar-teamets][style_team] hemvist
+
+### Kanaler för specifika ämnen
+
+Dessa kanaler tillhandahålls av det bredare rust-communityt och modereras ej
+av [modereringsteamet][mod_team].
+
+- [#rust-bots][bots_irc] ger notiser om rust från ett urval av bottar
+- [#rust-crypto][crypto_irc] är för diskussion om kryptografi i rust
+- [#rust-embedded][embedded_irc] är för folk som sysslar med inbyggda system i rust
+- [#rust-gamedev][gamedev_irc] är för folk som sysslar med spelutveckling i rust
+- [#rust-geo][rustgeo_irc] är för diskussion om GeoRust, ett geospatialverktyg skriven i rust
+- [#rust-machine-learning][machine_learning_irc] är för folk som sysslar med maskininlärning i rust
+- [#rust-networking][networking_irc] är för folk som sysslar med datornätverk och sådan utveckling i rust
+- [#rust-osdev][osdev_irc] är för folk som sysslar med utveckling av operativsystem i rust
+- [#rust-sci][sci_irc] är för folk som sysslar med vetenskaplig databehandling i rust
+- [#rust-wasm][wasm_irc] är för diskussion om att använda rust tillsammans med WebAssembly
+- [#rust-webdev][webdev_irc] är för folk som sysslar med webbutveckling i rust
+- [#hyper][hyper_irc] är för diskussion om Hyper, ett populärt http-bibliotek för rust
+- [#iron][iron_irc] är för diskussion om Iron, det is for discussion on Iron, det
+utökningsbara webbramverket för rust
+- [#nom][nom_irc] är för diskussion om Nom, en parser-combinator-bibliotek för rust
+- [#redox][redox_irc] är för diskussion om Redox, operativsystemet skrivet i rust
+- [#rocket][rocket_irc] är för diskussion om Rocket, ett populärt webbramverk för rust
+- [#serde][serde_irc] är för diskussion om Serde, ett populärt serialiseringsbibliotek för rust
+- [#servo][servo_irc] är för diskussion om Servo, webbläsarmotorn skriven i rust
+- [#xi][xi_irc] är för diskussion om Xi, texteditorn skriven i rust
+
+[IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
+[beginners_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners
+[bots_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-bots
+[br_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-br
+[cargo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23cargo
+[cn_org]: https://chat.rust-china.org/
+[community_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community
+[crypto_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-crypto
+[de_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-de
+[es_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-es
+[embedded_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-embedded
+[fr_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-fr
+[gamedev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev
+[internals_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[lang_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang
+[libs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[networking_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-networking
+[osdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev
+[ru_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-ru
+[rust_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
+[rustc_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[servo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23servo
+[webdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-webdev
+[docs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs
+[xi_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23xi
+[dev_tools_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-dev-tools
+[style_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23style
+[style_team]: team.html#Style-team
+[mod_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23mods
+[machine_learning_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-machine-learning
+[hyper_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23hyper
+[iron_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23iron
+[redox_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23redox
+[nom_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23nom
+[infra_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-infra
+[rustgeo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-geo
+[rocket_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rocket
+[serde_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23serde
+[sci_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-sci
+[wasm_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-wasm
+
+## Diskussionsforum
+
+Vi har två diskussionsforum för asynkron diskussion (dvs. inte med direktmeddelande)
+
+- [Användarnas forum][users_forum], ett ställe för att ställa frågor, klistra
+kodavsnitt, och diskussion om rust-projekt, osv.
+
+- [Intern-forumet][internals_forum], ett utrymme dedikerat för design och
+diskusson om implementation av rust självt (som innefattar cargo, standardbibiolteket,
+och annan essentiell infrastruktur).
+
+[users_forum]: https://users.rust-lang.org/
+[internals_forum]: https://internals.rust-lang.org/
+
+## YouTube-kanalen
+
+Rust har en [YouTube-kanal][youtube_channel] där presentationer och föreläsningar
+som ges vid användargrupper och konferenser av rust-communityts medlemmar laddas upp.
+
+[youtube_channel]: https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA
+
+## Användargrupper och Meetups
+
+Det finns mer än 90 [Användargrupper för Rust][user_group] världen över i
+över 35 länder. Folk i rust-communityt ses periodvis i dessa användargrupper.
+Det är en väldigt bra introduktion till communityt och ett bra sätt att
+lära sig och mingla med annat folk med liknande intressen. Möten hålls vanligtvis
+månadvis och väldigt informellt. Dessa möten är öppna för alla.
+
+Det finns en global [kalender][calendar] för att hålla koll på rust-evenemang.
+Kontakta [community-teamet][community_team] för att lägga till ditt egna evenemang.
+
+[user_group]: ./user-groups.html
+[calendar]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com
+
+## Rust-teamet
+
+Rust har en community-driven utvecklingsprocess där de flesta beslut tas genom
+öppen diskussion och konsensus under förvaltning av diverse [team][teams]:
+
+* [Core-teamet][core_team] ansvarar för att styra design- och
+utvecklings-processen, hålla uppsikt över introduktionen av ny funktionalitet,
+och i slutändan ta beslut för vilket det saknas konsensus (detta händer sällan).
+
+* [Språkteamet][language_team] ansvarar för design av ny funktionalitet i
+ språket.
+
+* [Biblioteksteamet][library_team] ansvarar för rusts standardbibliotek,
+ "rust-lang crates", och rusts språkkonventioner.
+
+* [Kompilatorteamet][compiler_team] ansvarar för kompilatorns interna
+angelägenheter och optimeringar.
+
+* [Utveckligsverktygsteamet][dev_tools_team] ansvarar för att sätta riktningen
+för verktyg för rustutveckling.
+
+* [Cargo-teamet][cargo_team] ansvarar för design och implementation av cargo.
+
+* [Infrastrukturteamet][infra_team] ansvarar för infrastruktur som stödjer
+ själva projektet: CI (continuous integration), distribution och generering av
+ releaser, bottar och statistik.
+
++ [Communityteamet][community_team] ansvarar för samordning av händelser,
+outreach, kommersiella användare, läromedel och exponering. De kan också
+rikta förfrågningar till rätt parter när det inte är tydligt vem som ska
+kontaktas om något "rostigt".
+
+* [Modereringsteamet][mod_team] ansvarar för att upprätthålla [uppförandekoden][coc].
+
+* [Dokumentationsteamet][doc_team] ansvarar för att säkerställa att rust har
+ fantastiskt bra dokumentation.
+
+Utöver de officiella team-uppställningarna har de flesta team en större
+uppsättning av kodgranskare som kan området och kan godkänna kod.
+
+Kontakta teamets ledare eller någon annan medlem som kan hjälpa dig att dig att
+komma igång om är intresserad av att bli involverad i någon av dessa team.
+
+[teams]: team.html
+[core_team]: team.html#Core-team
+[language_team]: team.html#Language-design-team
+[library_team]: team.html#Library-team
+[compiler_team]: team.html#Compiler-team
+[dev_tools_team]: team.html#Dev-tools-team
+[cargo_team]: team.html#Cargo-team
+[community_team]: team.html#Community-team
+[mod_team]: team.html#Moderation-team
+[doc_team]: team.html#Documentation-team
+[infra_team]: team.html#Infrastructure-team
+
+## Utveckling av rust
+
+Rust har haft över [2,000 olika bidragsgivare][authors], en siffra som växer
+varje vecka. [Det skulle vara underbart om du ville bli en av dem][contribute]!
+
+Som tidigare nämns är [rusts internforum][internals_forum] dedikerad till att
+diskutera design och implementation av rust. En hel del av diskussionen händer
+också på GitHub:
+
+- [huvud-repo][github] och [issue-trackern][issue_tracking] är
+ implementationsarbetets frontlinje. Våra granskare strävar efter att vara
+ vänliga och att hjälpa till att handleda nykomlingar, så tveka inte att öppna
+ en "pull request"!
+
+- [RFC-repo][rfcs] håller koll på vår "Request for Comment" process vilket
+ är huvudvägen genom vilken rust-communityt och teamen når konsensus om föreslagen
+ ny funktionalitet för språket och officiella bibliotek och verktyg.
+
+[authors]: https://thanks.rust-lang.org/rust/all-time
+[contribute]: contribute.html
+[github]: https://github.com/rust-lang/rust
+[rfcs]: https://github.com/rust-lang/rfcs
+[issue_tracking]: https://github.com/rust-lang/rust/issues
diff --git a/sv-SE/conduct.md b/sv-SE/conduct.md
new file mode 100644
index 000000000..3f5aed0ba
--- /dev/null
+++ b/sv-SE/conduct.md
@@ -0,0 +1,84 @@
+---
+layout: sv-SE/default
+title: Rusts uppförandekod · Programmeringsspråket Rust
+---
+
+# Rusts uppförandekod
+
+## Uppträdande
+
+**Kontakt**: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org)
+
++ Vi är hängivna till och ämnar att tillhandahålla en vänlig, säker
+och välkomnande miljö för alla, oavsett erfarenhetsnivå, könsidentitet och
+uttryck, sexuell läggning, funktionshinder, utseende, kroppsstorlek, om du
+är rasifierad, etnicitet, ålder, religion, nationalitet och andra likande drag.
++ På IRC, var god och undvik öppet sexuella smeknamn eller andra smeknamn som
+kan hindra en vänlig, säker och välkomnande miljö för alla.
+* Var vänlig och artig. Du behöver inte vara elak eller ohyfsad.
+* Respektera att folk har meningsskiljaktigheter och att alla designval och
+val av implementation för med sig avvägningar och diverse kostnader. Det finns
+sällan ett rätt svar.
+* Vänligen håll ostrukturerad kritik till ett minimum. Om du har bra idéer du vill
+experimentera med, skapa en "fork" och se hur det går.
+* Du kommer bli utesluten ifrån interaktion om du förolämpar, förnedrar eller
+trakasserar någon. Sådant beteénde är inte välkommet. Vi tolkar begreppet
+"trakassering" som definierat på Citizen Code of Conduct;
+Läs deras definition om det för dig är oklart vad som ingår i konceptet.
+Vi tolererar särskilt inte beteende som utesluter folk från socialt utsatta grupper.
+* Trakassering privat är också oacceptabelt. Oavsett vem du är, om du känner att
+du har blivit eller är trakasserad eller blivit obehagligt bemött av någon i communityt,
+var god kontakta då någon av kanalens ops (operatörer på en IRC-kanal) eller någon
+i [rusts modereringsteam](/team.html#Moderation) omgående. Oavsett om du bidrar ofta
+eller är ny till språket bryr vi oss om att göra communityt en säker plats för dig
+och vi står bakom dig.
+* Likaledes är spammning, trollning, flejmning, att hetsa eller annan
+uppmärksamhet-stjälande beteende ej välkommen.
+
+## Moderering
+
+Dessa är riktlinjerna för att upprätthålla våra uppföranderegler. Om du känner att en
+tråd är i behov av moderering, vänligen kontakta [rusts modereringsteam](/team.html#Moderation).
+
+1. Anmärkningar som bryter mot rusts uppförandekod och normer, inklusive hatiska,
+sårande, förtryckande eller uteslutande kommentarer, är inte tillåtna. (Svordomar
+är tillåtna, men aldrig riktade till en annan användare och aldrig på ett hatiskt sätt.)
+2. Anmärningar som moderatorerna tycker är olämpliga oavsett om det är angivet i
+uppförandekoden eller ej är också ej tillåtna.
+3. Moderatorer agerar först mot sådana anmärkningar med en varning.
+4. Om varningen ignoreras kommer användaren att bli "kickad," dvs. kickad från
+kommunikationskanalen för att lugna ner sig.
+5. Om användaren kommer tillbaka och fortsätter att skapa trubbel kommer de att bli
+bannade, dvs. uteslutna på obestämd tid.
+6. Moderatorer kan välja att med eget omdömme av-banna användaren om det var en
+den första överträdelsen och de ber den kränkta parten en genuin ursäkt.
+7. Om en moderator bannar någon och du tycker att det var obefogat, ta då upp det
+med moderatorn i fråga, eller med en annan moderator, **privat**. Klagomål om
+bannande av användare är inte tillåtet i en kanal.
+8. Moderatorer hålls till en högre standard än andra medlemmar i communityt.
+Om en moderator skapar en olämplig stämning eller situation kan de förvänta sig mindre
+spelrum än andra.
+
+I rust-communityt strävar vi efter att gå ett extra steg för att ta hand om varandra.
+Försök inte bara att vara tekniskt oklanderlig, försök också att vara ditt bästa jag.
+Undvik speciellt att flörta med stötande eller känsliga ämnen, speciellt om de inte
+har med ämnet att göra (dvs. är off-topic). Annars leder det ofta till onödigt bråk,
+sårade känslor och en försämrad tillit. Värst av allt kan det stöta bort folk från
+communityt helt.
+
+Om någon klagar på något du sa eller gjorde, motstå frestelsen att gå på defensiven.
+Sluta bara upp med vad de klagade på istället och be om ursäkt. Även om du känner dig
+missförstådd eller orättvist anklagad, är det troligt att det var något som du kunnat
+kommunicera bättre. Kom ihåg att det är ditt ansvar att få dina med-människor i
+rust-communitet att känna sig bekväma och välkomna. Alla vill komma överens och vi är
+alla här först och främst för att vi vill snacka om cool teknik. Du kommer att se att
+folk kommer att vara angelägna att anta goda avsikter och förlåta så länge du vinner
+deras förtroende.
+
+Riktlinjerna för tillsyn ovan nämnda gäller alla officiella rust-kanaler inklusive
+officiella IRC-kanaler (#rust, #rust-internals, #rust-tools, #rust-libs, #rustc, #rust-beginners, #rust-docs, #rust-community, #rust-lang, och #cargo);
+GitHub repon under rust-lang, rust-lang-nursery, och rust-lang-deprecated; och alla forum på rust-lang.org (users.rust-lang.org, internals.rust-lang.org).
+För andra projekt som antagit rusts uppförandekod, var god kontakta de som sköter dessa projekt för tillsyn. Om du vill använda den här uppförandekoden
+för ditt egna projekt, överväg då att explicit nämna din modereringspolicy eller att göra en kopia med din egna modereringspolicy för att undvika förvirring.
+
+*Anpassad från [Node.js policy om trollning](http://blog.izs.me/post/30036893703/policy-on-trolling) och [Contributor Covenant v1.3.0](http://contributor-covenant.org/version/1/3/0/).*
\ No newline at end of file
diff --git a/sv-SE/contribute-bugs.md b/sv-SE/contribute-bugs.md
new file mode 100644
index 000000000..8836c7386
--- /dev/null
+++ b/sv-SE/contribute-bugs.md
@@ -0,0 +1,64 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — att hitta, kategorisera, prioritera och fixa problem · Programmeringsspråket Rust
+---
+
+# Att bidra till rust — att hitta, kategorisera, prioritera och fixa problem
+
+Det dagliga underhållet av projetet kretsar kring rusts [issue tracker] och
+[issue tracker] och [pull requests][PR], och mer hjälp behövs alltid.
+Det enklaste sättet att komma igång med att bidra till rust är att leta efter
+etiketterna [E-easy] eller [E-mentor]. Dessa är ämnade att kunna lösas av nya
+rustprogrammerare.
+
+På issues ("problem") märkta `E-mentor` har en erfaren rust-utvecklare anmält
+sig frivilligt i kommentarerna för att handleda dig genom lösandet av problemet
+och att [skicka in en fix via pull requests på GitHub][pull]. Kontakta dem om problemet
+på issue trackern genom att [@nämna][@mentioning] deras namn i en kommentar, på IRC,
+eller via email. Notera att rust-utvecklare får många notiser och att det därför är
+lätt att missa några; tveka inte att hitta dem med alla till båds stående medel!
+
+Andra projekt i rust tillhandahåller likande uppgifter på nybörjarnivå inklusive
+webbläsaren [Servo], httpbiblioteket [hyper], källkodsformateraren [rustfmt], och
+projektet för unix-biblioteks-bindningar [nix], och källkodsförbättringsförslagsgivaren [clippy].
+
+Medan rust har en [extensiv testsvit][test] finns det alltid mer att testa.
+Etiketten [E-needstest] indikerar problem som tros ha fixats med saknar tester.
+Att skriva testfall är ett mycket bra sätt att förstå ett nytt projekt och att
+börja att bidra.
+
+Rust är alltid i behov av folk som kan kategorisera och prioritera problem:
+reproducera buggar, hitta mindre test-fall, etikettera, stänga lösta problem.
+Notera att du behöver upphöjda GitHub-privilegier för att etikettera, men detta
+är lätt att få för någon med lite erfarenhet i projektet. Fråga en [teammedlem][team]
+för att få dessa privilegier.
+
+När du har hittat dig runt projektet och skapat några
+dra pull requests inom ett visst område, överväg då att granska andras förslag.
+Bra granskningsförmåga är en sällsynt skicklighet och uppskattas alltid.
+
+Inget tidigare tillstånd krävs — börja bara att ge konstruktiva och artiga
+kommentarer på pull requests som intresserar dig. Om du behöver råd för hur man
+ger bra kodgranskning [läs denna guide][reviews].
+
+
+
+[@mentioning]: https://github.com/blog/821
+[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
+[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor
+[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest
+[PR]: https://github.com/rust-lang/rust/pulls
+[Servo]: https://github.com/servo/servo
+[clippy]: https://github.com/Manishearth/rust-clippy
+[hyper]: https://github.com/hyperium/hyper
+[issue tracker]: https://github.com/rust-lang/rust/issues
+[nix]: https://github.com/nix-rust/nix/
+[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests
+[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/
+[rustfmt]: https://github.com/rust-lang-nursery/rustfmt
+[team]: team.html
+[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md
+[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage
diff --git a/sv-SE/contribute-community.md b/sv-SE/contribute-community.md
new file mode 100644
index 000000000..541194324
--- /dev/null
+++ b/sv-SE/contribute-community.md
@@ -0,0 +1,78 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — att bygga communityt · Programmeringsspråket Rust
+---
+
+# Att bidra till rust — att bygga communityt
+
+Hjälp nybörjare, sprid ordet, möt intressant folk. Gör rust till det skinande
+exemplet för open-source-utveckling som vi alla vill att det ska vara.
+
+Håll ett öga på [#rust-beginners]-kanalen. Här är dit vi hänvisar nya
+rust-programmerare att be om hjälp, och det är kritiskt viktigt att de
+får snabba, korrekta och artiga svar. Likaledes är [Stack Overflow],
+[users.rust-lang.org], och [/r/rust], forum där rustprogrammerare ofta söker
+hjälp. Om du vill bli tränad på att svara programmerares frågor, [läs denna guide][helpful].
+
+Om du redan är erfaren i någon del av projektet, håll ett öga för potentiella
+buggar märkta med [E-easy]. När du ser ett lätt problem på bug-trackern som du
+vet hur man fixar, ge då en beskrivning av fixen och etikettera den med E-easy.
+Notera att vad som kan vara självklart för dig är kanske inte det för en ny
+person som vill bidra till rust, och det är viktigt att beskriva problemet och
+lösningen tydligt. Det är därför också till hjälp att tria E-lätta buggar
+för dåliga beskrivningar och förbättra dem.
+
+Erfarna utvecklare som är tålmordiga och kommunicerar tydligt borde också
+överväga att [vara mentor för nya bidragare till rustprojektet][mentor]. Märk
+enkla issues (problem) med [E-mentor] och nämn i en kommentar att du kommer
+handleda lösningen av problemet. Förvänta dig att folk kommer kontakta dig om
+problemet och försök att svara snabbt.
+
+Underhåll av nybörjar-nivå-uppgifter är inte endast bra för rust-projektet självt
+utan alla projekt. Om ditt projekt har en konstant tillgång på nybörjaruppgifter
+kan du själv inrätta ett sådant program. ***Att organisera nybörjaruppgifter
+är en av de mest effektiva sätt att få in nya programmerare till projektet.***
+Om du vill bli tränad på att handleda nya utvecklare, [läs då denna guide][mentor-guide].
+
+Snacka om vad du arbetar med i den veckovisa "vad sysslar alla med denna veckan"-trådar
+på [/r/rust] och [users.rust-lang.org], och säg vad du behöver hjälp med. Dessa är
+mycket bra startpunkter för collaboration.
+
+Förespråka rust i ditt egna lokalsamhälle. Rusts [användargrupper][user groups]
+och [evenemang][events] är unika och spännande delar av rust-upplevelsen: det
+finns så många, och de finns överallt! Om du inte har vart på sådana
+tillställningar, gå och njut av nya upplevelser. Om det inte finns något rust-relaterat
+i din närhet, fundera då på att organisera någon själv. Du kan kolla intresset och
+påannonsera evenemang och händelser på [/r/rust] eller [users.rust-lang.org]. Kontakta
+[community-teamet][community team] för att visa evenemang på kalendern, och bli därför
+annoncerad på [Denna Veckan i Rust][This Week in Rust].
+
+Kom igåg att medan du förespråkar rust att respektera andras åsikter —
+Alla kommer inte vara mottagliga för rust, och det är helt ok.
+
+Träffa andra byggare av rust-communityt i [#rust-community].
+
+
+
+[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners
+[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community
+[/r/rust]: https://reddit.com/r/rust
+[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
+[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor
+[Stack Overflow]: https://stackoverflow.com/questions/tagged/rust
+[This Week in Rust]: https://this-week-in-rust.org
+[community team]: https://www.rust-lang.org/team.html#Community
+[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com
+[helpful]: https://codeblog.jonskeet.uk/2009/02/17/answering-technical-questions-helpfully/
+[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088
+[mentor-guide]: https://manishearth.github.io/blog/2016/01/03/making-your-open-source-project-newcomer-friendly/
+[user groups]: user-groups.html
+[users.rust-lang.org]: https://users.rust-lang.org
diff --git a/sv-SE/contribute-compiler.md b/sv-SE/contribute-compiler.md
new file mode 100644
index 000000000..aadfb85a1
--- /dev/null
+++ b/sv-SE/contribute-compiler.md
@@ -0,0 +1,108 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — språket, kompilatorn och standardbiblioteket · Programmeringsspråket rust
+---
+
+# Att bidra till rust — språket, kompilatorn och standardbiblioteket
+
+Källkoden för kompilatorn och standardbiblioteket är i huvud-repot och
+deras underhåll är det primära målet för det repot. Många etiketter på
+issue trackern är relaterade till det. Några av de mer fruktbara etiketterna
+inbegriper [A-codegen], för översättning av rust-kod till LLVM IR;
+[A-debuginfo], för generation av metadata använt av debuggers;
+[A-diagnostics], feedbacken som kompilatorn ger vid fel;
+[A-libs], problem i standardbiblioteket;
+[A-macros] och [A-syntaxext], båda relaterade till syntax extensions
+("syntax-utökningar"); och [A-typesystem], som handlar om typsystemet.
+
+Det finns ingen välunderhållen guide till kompilatorns arkitektur men
+[det finns en liten översikt i repot][rustc-guide].
+[API-dokumentationen för de crates som utgör kompilatorn][internals-docs] kan
+hjälpa till med att navigera i koden, likväl som källkods-browsern [Rust DXR].
+[Guiden till rusts testsvit][testsuite] kan lära dig hur du kan använda rusts
+byggsystem effektivt likväl som att köra [`make tips`][tips] i terminalen.
+
+Under överskådlig framtid är en av de initiativen i utvecklingen av
+rust-kompilatorn att konvertera dess interna mekanismer från att
+arbete direkt på det abstrakta syntax trädet (AST) till att arbeta med
+och på [en mellanliggande representation vid namn MIR][mir].
+Detta arbete förväntas uppna upp för många nya möjligheter genom att
+förenkla kompilatorn, och hjälp behövs för att t.ex skapa ett MIR-baserat
+översättningssteg, lägga till MIR-baserade optimeringar och implementera
+inkrementell kompilering. Det finns tillsvidare ingen enskild resurs för
+information om arbetet som krävs här, men fråga på [internals.rust-lang.org]
+eller [#rust-internals] för att bli guidad.
+
+[Det är pinsamt när vår kompilator kraschar][ice] — den
+fruktade 'internt-kompilator-fel' (ICE). Etiketten [I-ICE]
+håller koll på dessa och det finns ofta många sådana märkta problem.
+Dessa är oftast bra buggar att börja med eftersom det är lätt att veta
+när du har fixat dom och de är ofta relativt fristående.
+
+Rustkods prestanda är en av dess stora fördelar; och prestandan på rustkompilatorn
+är en av dess stora svagheter. Förbättringar av körsningstid eller speciellt
+prestandan på kompileringstiden är mycket uppskattade. Etiketterna [I-slow] och
+[A-optimization] är för körningstidsprestanda, och [I-compiletime] för
+kompileringstid. Vi har en [sida som håller koll på kompileringstidsprestanda][rustc-perf]
+på ett antal projekt. Kompilatorflaggan `-Z time-passes` kan hjälpa till att
+debugga kompilatorprestanda, och rustkod kan profilas med standard-profilers såsom
+`perf` på Linux.
+
+Större ny funktionalitet genomgår en [Förfrågningar för kommentarer (RFC)][rfc]
+process, igenom vilken en design för funktionaliteten bestäms. Denna process är
+öppen för alla. Det är en social process utvecklare emellan som redan har olika
+mängd erfarenhet av att arbeta tillsammas och det rekommenderas att bli involverad
+sakta — att bidra en snabbskriven RFC utan att förstå ämnets historiska,
+tekniska eller sociala kontext är ett lätt sätt att göra ett dåligt intryck och
+att bli besviken på resultatet. Läs den tidigare nämnda readme-filen för att bättre
+förstå hur det hela går till. Många idéer har debatterats under rusts historia.
+Vissa har avvisats, några har skjutits upp på framtiden och [issue trackern][rfc-issues]
+för RFCs katalogiserar vissa önskemål som ännu inte blivit en del av språket.
+Strax innan en RFC blir accepterad för implementation går den in i en
+'sista period för kommentarer'-fas, som indikeras av etiketten
+[final-comment-period på rust-lang/rfcs repot][rfc-fcp]. Likaledes går ny
+funktionalitet igenom en
+[final-comment-period i rust-lang/rust repot][issue-fcp] innan den blir
+aktiverad och användbar i den stabila kompilatorn (kallas för 'ungating').
+Båda FCPs är kritiska stunder att bli involverad och uttrycka åsikter om
+språkets utvecklingsriktning. FCPs påannonsers i de veckovisa sub-team
+rapporterna på [internals.rust-lang.org].
+
+Träffa andra rust-kompilator ingenjörer i [#rustc], språkdesigners i
+[#rust-lang], och bibliotekdesigners i [#rust-libs].
+
+
+
+
+[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang
+[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen
+[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo
+[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics
+[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs
+[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros
+[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization
+[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext
+[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem
+[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE
+[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime
+[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow
+[Rust DXR]: https://dxr.mozilla.org/rust/source/src
+[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380
+[internals-docs]: https://manishearth.github.io/rust-internals-docs
+[internals.rust-lang.org]: https://internals.rust-lang.org/
+[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period
+[mir]: https://github.com/rust-lang/rust/issues/27840
+[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period
+[rfc-issues]: https://github.com/rust-lang/rfcs/issues
+[rfc]: https://github.com/rust-lang/rfcs#table-of-contents
+[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md
+[rustc-perf]: http://ncameron.org/perf-rustc/
+[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md
+[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48
diff --git a/sv-SE/contribute-docs.md b/sv-SE/contribute-docs.md
new file mode 100644
index 000000000..1d93425c7
--- /dev/null
+++ b/sv-SE/contribute-docs.md
@@ -0,0 +1,70 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — dokumentation · Programmeringsspråket Rust
+---
+
+# Att bidra till rust — dokumentation
+
+Dokumentation är aldrig bra nog, och det finns aldrig tillräckligt av det.
+Många aspekter av rusts dokumentaton kräver ej djup kunskap för att förbättra.
+Att skriva, granska, och redigera dokumentation är bra sätt att lära sig rust på.
+Därutöver är förbättringar på dokumentationen lättidentifierbara och obegränsade.
+Gillar du inte hur något läses? Har du hittat någon odokumenterad information?
+Dina pull requests kommer bli glatt välkomnade.
+
+***Den dokumentation du kan skriva som hjälper ekosystemet mest är
+[för crates som utgör rusts "ekosystem"][crate_docs]***. Medan standardbibliotekets
+dokumentation är relativt utförlig är detsamma ej sant för
+[många populära crates och verktyg][awesome-rust] som rustprogrammerare
+använder varje dag. Att bidra med API-dokumentation till ett populärt rustprojekt
+kommer ge dig evig uppskattning från de som underhåller projektet.
+
+[Boken (om rust)][The Book] är den primära källan för dokumentation om rust,
+den underhålls i huvudrepot. Den har sig egna problem-etikett, [A-book] och
+förbättras ständigt. Annan dokumentation i huvudrepot inbegriper
+[rusts referenshandbok][The Rust Reference],
+[standardbibliotekets API-dokumentation][std],
+[den sk. Rustonomicon][The Rustonomicon] (en guide till att använda `unsafe`
+på ett korrekt sätt; begreppet härör ur kombinationen "rust" och "necronomicon").
+[Rusts stilguide][Rust Style Guidelines] är så ofullständig att den inte länkas
+till ofta; den som är ambitiös kan bidra mycket där. [Indexet över fel][err]
+tillhandahåller utförliga beskrivningar av diverse felmeddelanden som kompilatorn
+kan ge. Allteftersom nya felmeddelanden läggs till i kompilatorn
+[måste dokumentationen underhållas][err-issue]. Därför finns det alltid
+felmeddelanden som inte beskrivs i indexet att lägga till och beskriva.
+Den större delen av dokumentationen i huvudrepot finns i mappen [src/doc].
+I issue-trackern märks problem relaterade till denna dokumentation med etiketten
+[A-docs]. Till sist är detta dokument och andra webbsidematerial underhållna i
+[rustwebbsidans gitrepo][Rust website Git repository]. För att bidra till den
+behöver du bara redigera och skicka in en pull request.
+
+En hel del viktig rustdokumentation finns ej i huvudrepot eller underhålls inte
+av projektet men är fortfarande kritiskt viktig för rusts framgång.
+Exempel på utmärkt rustdokumentation som utvecklas aktivt och behöver folk som
+bidrar är [Rust By Example], [Rust Design Patterns], och [rust-rosetta].
+För annan existerande dokumentationsprojekt att bidra till, se [rust-learning].
+
+Träffa annat folk som dokumenterar rust i [#rust-docs].
+
+
+
+[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs
+[A-book]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book
+[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs
+[Rust By Example]: https://github.com/rust-lang/rust-by-example
+[Rust Design Patterns]: https://github.com/nrc/patterns
+[Rust Style Guidelines]: https://doc.rust-lang.org/style/index.html
+[The Book]: https://doc.rust-lang.org/book/index.html
+[The Rust Reference]: https://doc.rust-lang.org/reference
+[The Rustonomicon]: https://doc.rust-lang.org/nomicon/index.html
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791
+[err-issue]: https://github.com/rust-lang/rust/issues/24407
+[err]: https://doc.rust-lang.org/error-index.html
+[rust-learning]: https://github.com/ctjhoa/rust-learning
+[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta
+[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc
+[std]: https://doc.rust-lang.org/std/index.html
+[Rust website Git repository]: https://github.com/rust-lang/rust-www
diff --git a/sv-SE/contribute-libs.md b/sv-SE/contribute-libs.md
new file mode 100644
index 000000000..ca774b5d0
--- /dev/null
+++ b/sv-SE/contribute-libs.md
@@ -0,0 +1,64 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — bibliotek · Programmeringsspråket Rust
+---
+
+# Att bidra till rust — bibliotek
+
+Om du vill bidra till rust genom att skriva volymer av rustkod så är
+bibliotek där du kan göra det. Eftersom rust är ett nytt språk finns
+det många typer av bibliotek som antingen inte finns än eller är
+ofullständiga och är i behov av förbättring eller andra konkurrens.
+
+Att bestämma vad du ska skriva som kommer ha effekt på ekosystemet och vara
+kul är en vanlig svårighet. Här är ett antal idéer som kan hjälpa:
+
+* Läs och delta i de veckovisa "vad jobbar alla med denna veckan"-trådar
+ ("what's everyone working on this week") på subredditen [/r/rust] och
+ [users.rust-lang.org]. Dessa är fyllda med spännande nyheter från andra
+ rustprogrammerare som är i behov av medarbetare.
+* Bekanta dig med de bästa rust-biblioteken via [awesome-rust] och [libs.rs].
+* Vissa större projekt, inklusive webbläsaren [Servo], http-biblioteket [hyper],
+ källkodsformateraren [rustfmt], och unix-bindnings-biblioteket [nix], och
+ kodförbättringstipsaren [clippy] märker problem med 'easy' etiketter för nya
+ medarbetare.
+* Bli involverad med en av de mest aktiva rust-orienterade GitHub organisationerna
+ såsom: [PistonDevelopers], [servo], [redox-os], [iron], [contain-rs] och [hyperium].
+ Det är ofta enklare att hitta ett ställe att passa in i i dessa del-communities.
+ De är också i större behov av hjälp än rust-lang organisationen självt och de är
+ fyllda med erfarna rustutvecklare som kan vägleda dig.
+* Hjälp till att guida bibliotek från [rust-lang-nursery] till huvudorganisationen rust-lang.
+ Dessvärre finns det inte mycket dokumentation om vad som behövs göras här. Du
+ kan dock fråga på kanalen [#rust-libs].
+* Ta en titt på RFC-issue-trackern för ett [efterfrågat bibliotek][requested] och bygg det.
+* Håll koll på [Github Trending][trending] för rustprojekt som är aktiva just nu.
+
+Som biblioteksförfattare behöver du vara medveten om
+[bästa praxis för rustbibliotek][lib-prac].
+
+Träffa andra rustbibliotekdesigners i [#rust-libs].
+
+
+
+[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[/r/rust]: https://reddit.com/r/rust
+[PistonDevelopers]: https://github.com/PistonDevelopers
+[Servo]: https://github.com/servo/servo
+[Servo]: https://github.com/servo/servo
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[clippy]: https://github.com/Manishearth/rust-clippy
+[contain-rs]: https://github.com/contain-rs
+[hyper]: https://github.com/hyperium/hyper
+[hyperium]: https://github.com/hyperium
+[iron]: https://github.com/iron
+[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/
+[libs.rs]: http://libs.rs
+[nix]: https://github.com/nix-rust/nix/
+[redox-os]: https://github.com/redox-os
+[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library
+[rust-lang-nursery]: https://github.com/rust-lang-nursery
+[rustfmt]: https://github.com/rust-lang-nursery/rustfmt
+[trending]: https://github.com/trending?l=rust
+[users.rust-lang.org]: https://users.rust-lang.org
diff --git a/sv-SE/contribute-tools.md b/sv-SE/contribute-tools.md
new file mode 100644
index 000000000..ea7df36b2
--- /dev/null
+++ b/sv-SE/contribute-tools.md
@@ -0,0 +1,38 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust — verktyg, IDEs och infrastruktur · Programmeringsspråket Rust
+---
+
+# Att bidra till rust — verktyg, IDEs och infrastruktur
+
+Verktyg spelar en väldigt stor roll i ett programmeringsspråks framgång,
+och det finns en hel del kvar att implementera.
+***Ett stort fokus i rustutveckling är nu att [förbättra IDE-upplevelsen][ides]***.
+Där i ingår arbete genom hela rusts stack från kompilatorn själv till din
+favorit-IDE. Följ länken för mer information.
+
+Både Cargo, rusts pakethanterare och rustdoc,
+rusts dokumentationsgenerator, medan den är fullfjädrad och fuktionell,
+lider av en brist på utvecklare. Rustdoc har många öppna problem (issues) märkta
+med etiketten [A-rustdoc] i huvudrepot. De är för det mesta buggar och att bidra
+handlar om att fixa en bug och att skicka in en pull-request. Cargo har
+[dess egna repo och problem/issues][Cargo]. De som är intresserade av att bidra
+kan vilja introducera sig själva i kanalen [#cargo].
+
+Medan rust kan köras både under debuggers gdb och lldb med begränsan framgång
+finns det fortfarande många fall där debugging inte fungerar som förväntat.
+Issues/problem för dessa sorterar under etiketten [A-debuginfo].
+
+För idéer till fler verktygsprojekt att bidra till, se [awesome-rust].
+
+Det fimms pfta fler intressanta verktygsprojekt som bara vänta på rätt personer
+att dyka upp och implementera dem. Diskutera med andra rustverktygsentusiaster i
+[#rust-tools].
+
+[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools
+[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo
+[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc
+[Cargo]: https://github.com/rust-lang/cargo/issues
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[ides]: https://forge.rust-lang.org/ides.html
diff --git a/sv-SE/contribute-translations.md b/sv-SE/contribute-translations.md
new file mode 100644
index 000000000..31ce14faf
--- /dev/null
+++ b/sv-SE/contribute-translations.md
@@ -0,0 +1,8 @@
+---
+layout: sv-SE/default
+title: Att översätta rust-lang.org till andra språk för att anamma internationalisering
+---
+
+# Rust är universellt
+
+Någon dokumentation om att bidra med översättningar!
diff --git a/sv-SE/contribute.md b/sv-SE/contribute.md
new file mode 100644
index 000000000..7a453152f
--- /dev/null
+++ b/sv-SE/contribute.md
@@ -0,0 +1,60 @@
+---
+layout: sv-SE/default
+title: Att bidra till rust · Programmeringsspråket Rust
+---
+
+# Att bidra till rust
+
+Du har börjat att lära dig rust. Du älskar det, och vill vara en del av det.
+Om du inte vet hur du ska bli involverad kommer den här sidan att hjälpa till.
+
+**Hittade du en bugg och behöver rapportera den?**
+[Följ buggrapporteringsguiden][bugs]. Tack på förhand!
+
+Rust är ett expansivt system av projekt, av vilket det mest framträdande
+underhålls av [rustprojektets utvecklare][devs] i
+[rust-lang organisationen på GitHub][rust-lang]. Nykomlingar kan vara intresserade
+av projektets [CONTRIBUTING.md]-fil som förklarar hur man bidrar till repot
+[rust-lang/rust].
+
+Det finns många sätt att bidra till rusts framgång.
+Denna guiden fokuserar på nya avenyer för den nya bidragsgivaren:
+
+* [Att hitta, categorisera, prioritera och fixa problem](contribute-bugs.html).
+ Det grundläggande arbetet att underhålla ett stort och aktivt projekt likt rust.
+* [Dokumentation](contribute-docs.html). Inte bara officiell dokumentation,
+ utan också för crates, bloginlägg och andra inofficiella källor och resurser.
+* [Bygga communityt](contribute-community.html). Att hjälpa andra rustprogrammerare
+ och udvidga rusts räckvidd.
+* [Verktyg, IDE:er och infrastruktur](contribute-tools.html). De viktiga
+ beståndsdelarna som gör ett programmeringsspråk praktiskt och smärtfritt att använda.
+* [Bibliotek](contribute-libs.html). Rusts lämplighet för en viss uppgift är mest
+ avhängig tillgången på bibliotek med hög kvalité.
+* [Språk, kompilator och standardbiblioteket](contribute-compiler.html).
+ Språkdesign, implementation av ny funktionalitet och förbättring av prestanda.
+* [Internationalisering](contribute-translations.html). Hjälp till att sprida
+ rusts kärlek genom att översätta vår webbsida till alla språk.
+
+Om du behöver mer vägledning, fråga på [#rust-internals] eller [internals.rust-lang.org].
+
+Vi är stolta över att upprätthålla en civiliserad diskurs. I detta syfte förväntas
+de som bidrar följa vår [uppförandekod][coc]. Om du har frågor om detta kan du
+gärna vända dig tilll [communityteamet][community team].
+
+
+
+[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md
+[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports
+[coc]: https://www.rust-lang.org/conduct.html
+[community team]: https://www.rust-lang.org/team.html#Community
+[dev_proc]: community.html#rust-development
+[devs]: https://github.com/rust-lang/rust/graphs/contributors
+[internals.rust-lang.org]: https://internals.rust-lang.org/
+[rust-lang/rust]: https://github.com/rust-lang/rust
+[rust-lang]: https://github.com/rust-lang
diff --git a/sv-SE/documentation.md b/sv-SE/documentation.md
new file mode 100644
index 000000000..1cdcb427c
--- /dev/null
+++ b/sv-SE/documentation.md
@@ -0,0 +1,105 @@
+---
+layout: sv-SE/default
+title: Dokumentation om rust · Programmeringsspråket Rust
+---
+
+# Dokumentation om rust
+
+Om du hitintills inte set rust alls så är det första du borde läsa
+introduktionen till boken [Programmeringsspråket Rust][book]. Den kommer ge dig
+en god uppfattning om vad rust är, hur du installerar det, samt förklara språkets
+syntax och koncept. När du har läst klart boken kommer du vara en novis
+rustutvecklare och kommer ha få ett bra grepp på de idéer som ligger till
+grund för rust.
+
+## Att lära sig rust
+
+[Programmeringsspråket Rust][book]. Boken "Programmeringsspråket Rust", även känd
+som "Boken" kommer introducera huvudämnena som är viktiga för att lära sig rust
+och ta dig till den punkt då du kan vara produktiv. Boken är språkets primära
+officiella dokument.
+
+[Rust by Example][rbe]. En samling av själv av fristående exempel skriva i rust
+om en rad olika ämnen som är körbara i webbläsaren.
+
+[Vanliga frågor][faq].
+
+[Den sk. Rustonomicon][nomicon]. En hel bok dedikerad till att förklara hur
+man skriver osäker (`unsafe`) rustkod. Den är till för rustprogrammerare på
+en avancerad nivå.
+
+[rust-learning]. En kollektiv av resurser för att lära sig rust som underhålls
+av communityt.
+
+[book]: https://doc.rust-lang.org/book/
+[rbe]: http://rustbyexample.com
+[faq]: faq.html
+[nomicon]: https://doc.rust-lang.org/nomicon/
+[rust-learning]: https://github.com/ctjhoa/rust-learning
+
+## Referenser
+
+[Standardbibliotekets API-referenshandbok][api]. Dokumentation för
+standardbiblioteket.
+
+[docs.rs]. Dokumentation för alla crates publicerade på [crates.io].
+
+[Rusts referenshandbok][ref]. Medan rust inte har en formell specifikation
+försöker referensen att beskriva hur rust fungerar i detail. Den tenderar
+att vara utdaterad.
+
+[Indexet över syntax][syn]. Denna appendix från Boken innehåller diverse exempel
+för all syntax i rust korsrefererad med det kapitel i boken som beskriver exemplet.
+
+[Guiden till Cargo][cargo]. Dokumentation för cargo, rusts pakethanterare.
+
+[Index över kompilatorns felmeddelande][err]. Utförliga beskrivningar av
+felmeddelande som kompilatorn genererar.
+
+[Release Notes][release_notes]. En lista på förändringar som skett under varje release.
+
+[Plattformsstöd][platform_support]. Lista av plattformar i varje tier ("stödnivå").
+
+[api]: https://doc.rust-lang.org/std/
+[syn]: https://doc.rust-lang.org/book/syntax-index.html
+[ref]: https://doc.rust-lang.org/reference
+[cargo]: http://doc.crates.io/guide.html
+[err]: https://doc.rust-lang.org/error-index.html
+[release_notes]: https://github.com/rust-lang/rust/blob/stable/RELEASES.md
+[docs.rs]: https://docs.rs
+[crates.io]: https://crates.io
+[platform_support]: https://forge.rust-lang.org/platform-support.html
+
+## Projektets policier
+
+[Rusts säkerhetspolicy][security]. Projektets policier för att rapportera,
+fixa och avslöja säkerhetsrelaterade buggar.
+
+[Rusts policy kring upphovsrätt och varumärke][legal].
+
+Rusts upphovsrätter ägs av rustsprojektets utvecklare
+("The Rust Project Developers"), och dess varumärken ägs av Mozilla.
+Lämplig användning av Rusts varumärken beskrivs här.
+
+[Uppförandekod][coc]. Gäller för organisationen rust-lang på GitHub,
+de officiella forumen, IRC-kanalerna och olika delar av rust-världen.
+
+[security]: security.html
+[legal]: legal.html
+[coc]: https://www.rust-lang.org/sv-SE/conduct.html
+
+## Nattlig och beta-dokumentation
+
+Mycket av den officiella dokumentationen om rust är också tillgänglig för
+[nattliga][nightly] och [beta-][beta]releaser utöver den dokumentationen
+för den stabila versionen av rust ovan länkad.
+
+[nightly]: https://doc.rust-lang.org/nightly/
+[beta]: https://doc.rust-lang.org/beta/
+
+## Icke-engelska resurser
+
+För resurser på andra språk än engelska, se de
+[lokala specifika länkarna i rust-learning][locale].
+
+[locale]: https://github.com/ctjhoa/rust-learning#locale-links
diff --git a/sv-SE/downloads.html b/sv-SE/downloads.html
new file mode 100644
index 000000000..0f3bde88d
--- /dev/null
+++ b/sv-SE/downloads.html
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/sv-SE/faq.md b/sv-SE/faq.md
new file mode 100644
index 000000000..c81c560c3
--- /dev/null
+++ b/sv-SE/faq.md
@@ -0,0 +1,1671 @@
+---
+layout: sv-SE/faq
+title: Frequently Asked Questions · The Rust Programming Language
+---
+
+# Frequently Asked Questions
+
+
+This page exists to answer common questions about the Rust programming language. It is not a complete guide to the language, nor is it a tool for teaching the language. It is a reference to answer oft-repeated questions people in the Rust community encounter, and to clarify the reasoning behind some of Rust's design decisions.
+
+
+
+If there is some common or important question you feel is wrongly left unanswered here, feel free to help us fix it.
+
+
+To design and implement a safe, concurrent, practical systems language.
+
+Rust exists because other languages at this level of abstraction and efficiency are unsatisfactory. In particular:
+
+1. There is too little attention paid to safety.
+2. They have poor concurrency support.
+3. There is a lack of practical affordances.
+4. They offer limited control over resources.
+
+Rust exists as an alternative that provides both efficient code and a comfortable level of abstraction, while improving on all four of these points.
+
+
+
+No. Rust started as Graydon Hoare's part-time side project in 2006 and remained so for over 3 years. Mozilla got involved in 2009 once the language was mature enough to run basic tests and demonstrate its core concepts. Though it remains sponsored by Mozilla, Rust is developed by a diverse community of enthusiasts from many different places around the world. The [Rust Team](https://www.rust-lang.org/team.html) is composed of both Mozilla and non-Mozilla members, and `rust` on GitHub has had over [1,900 unique contributors](https://github.com/rust-lang/rust/) so far.
+
+As far as [project governance](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) goes, Rust is managed by a core team that sets the vision and priorities for the project,
+guiding it from a global perspective. There are also subteams to guide and foster development of particular areas of interest, including the core language, the compiler, Rust libraries, Rust tools, and moderation of the official Rust communities. Designs in each of these areas are advanced through an [RFC process](https://github.com/rust-lang/rfcs). For changes which do not require an RFC, decisions are made through pull requests on the [`rustc` repository](https://github.com/rust-lang/rust).
+
+
+
+1. We do not employ any particularly cutting-edge technologies. Old, established techniques are better.
+2. We do not prize expressiveness, minimalism or elegance above other goals. These are desirable but subordinate goals.
+3. We do not intend to cover the complete feature-set of C++, or any other language. Rust should provide majority-case features.
+4. We do not intend to be 100% static, 100% safe, 100% reflective, or too dogmatic in any other sense. Trade-offs exist.
+5. We do not demand that Rust run on "every possible platform". It must eventually work without unnecessary compromises on widely-used hardware and software platforms.
+
+
+
+The main project is [Servo](https://github.com/servo/servo), an experimental browser engine Mozilla is working on. They are also working to [integrate Rust components](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) into Firefox.
+
+
+
+The two biggest open source Rust projects right now are [Servo](https://github.com/servo/servo) and the [Rust compiler](https://github.com/rust-lang/rust) itself.
+
+
+
+The easiest way to try Rust is through the [playpen](https://play.rust-lang.org/), an online app for writing and running Rust code. If you want to try Rust on your system, [install it](https://www.rust-lang.org/install.html) and go through the [Guessing Game](https://doc.rust-lang.org/stable/book/second-edition/ch02-00-guessing-game-tutorial.html) tutorial in the book.
+
+
+
+There are several ways. You can:
+
+- Post in [users.rust-lang.org](https://users.rust-lang.org/), the official Rust users forum
+- Ask in the official [Rust IRC channel](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org)
+- Ask on [Stack Overflow](https://stackoverflow.com/questions/tagged/rust) with the "rust" tag
+- Post in [/r/rust](https://www.reddit.com/r/rust), the unofficial Rust subreddit
+
+
+
+Rust started with a goal of creating a safe but usable systems programming language. In pursuit of this goal it explored a lot of ideas, some of which it kept (lifetimes, traits) while others were discarded (the typestate system, green threading). Also, in the run up to 1.0 a lot of the standard library was rewritten as early designs were updated to best use Rust's features and provide quality, consistent cross-platform APIs. Now that Rust has reached 1.0, the language is guaranteed to be "stable"; and while it may continue to evolve, code which works on current Rust should continue to work on future releases.
+
+
+
+Rust's language versioning follows [SemVer](http://semver.org/), with backwards incompatible changes of stable APIs only allowed in minor versions if those changes fix compiler bugs, patch safety holes, or change dispatch or type inference to require additional annotation. More detailed guidelines for minor version changes are available as approved RFCs for both the [language](https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md) and [standard library](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md).
+
+Rust maintains three "release channels": stable, beta, and nightly. Stable and beta are updated every six weeks, with the current nightly becoming the new beta, and the current beta becoming the new stable. Language and standard library features marked unstable or hidden behind feature gates may only be used on the nightly release channel. New features land as unstable, and are "ungated" once approved by the core team and relevant subteams. This approach allows for experimentation while providing strong backwards-compatibility guarantees for the stable channel.
+
+For additional details, read the Rust blog post ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html)
+
+
+
+No, you cannot. Rust works hard to provide strong guarantees about the stability of the features provided on the beta and stable channels. When something is unstable, it means that we can't provide those guarantees for it yet, and don't want people relying on it staying the same. This gives us the opportunity to try changes in the wild on the nightly release channel, while still maintaining strong guarantees for people seeking stability.
+
+Things stabilize all the time, and the beta and stable channels update every six weeks, with occasional fixes accepted into beta at other times. If you're waiting for a feature to be available without using the nightly release channel, you can locate its tracking issue by checking the [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) tag on the issue tracker.
+
+
+
+"Feature gates" are the mechanism Rust uses to stabilize features of the compiler, language, and standard library. A feature that is "gated" is accessible only on the nightly release channel, and then only when it has been explicitly enabled through `#[feature]` attributes or the `-Z unstable-options` command line argument. When a feature is stabilized it becomes available on the stable release channel, and does not need to be explicitly enabled. At that point the feature is considered "ungated". Feature gates allow developers to test experimental features while they are under development, before they are available in the stable language.
+
+
+
+The Apache license includes important protection against patent aggression, but it is not compatible with the GPL, version 2. To avoid problems using Rust with GPL2, it is alternately MIT licensed.
+
+
+
+This is partly due to preference of the original developer (Graydon), and partly due to the fact that languages tend to have a wider audience and more diverse set of possible embeddings and end-uses than products such as web browsers. We'd like to appeal to as many of those potential contributors as possible.
+
+
+
+Fast! Rust is already competitive with idiomatic C and C++ in a number of benchmarks (like the [Benchmarks Game](https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) and [others](https://github.com/kostya/benchmarks)).
+
+Like C++, Rust takes [zero-cost abstractions](http://blog.rust-lang.org/2015/05/11/traits.html) as one of its core principles: none of Rust's abstractions impose a global performance penalty, nor is there overhead from any runtime system in the traditional sense.
+
+Given that Rust is built on LLVM and strives to resemble Clang from LLVM's perspective, any LLVM performance improvements also help Rust. In the long run, the richer information in Rust's type system should also enable optimizations that are difficult or impossible for C/C++ code.
+
+
+
+No. One of Rust's key innovations is guaranteeing memory safety (no segfaults) *without* requiring garbage collection.
+
+By avoiding GC, Rust can offer numerous benefits: predictable cleanup of resources, lower overhead for memory management, and essentially no runtime system. All of these traits make Rust lean and easy to embed into arbitrary contexts, and make it much easier to [integrate Rust code with languages that have a GC](http://calculist.org/blog/2015/12/23/neon-node-rust/).
+
+Rust avoids the need for GC through its system of ownership and borrowing, but that same system helps with a host of other problems, including
+[resource management in general](http://blog.skylight.io/rust-means-never-having-to-close-a-socket/) and [concurrency](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html).
+
+For when single ownership does not suffice, Rust programs rely on the standard reference-counting smart pointer type, [`Rc`](https://doc.rust-lang.org/std/rc/struct.Rc.html), and its thread-safe counterpart, [`Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html), instead of GC.
+
+We are however investigating *optional* garbage collection as a future
+extension. The goal is to enable smooth integration with
+garbage-collected runtimes, such as those offered by the
+[Spidermonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey)
+and [V8](https://developers.google.com/v8/?hl=en) JavaScript engines.
+Finally, some people have investigated implementing
+[pure Rust garbage collectors](https://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/)
+without compiler support.
+
+
+
+The Rust compiler doesn't compile with optimizations unless asked to, [as optimizations slow down compilation and are usually undesirable during development](https://users.rust-lang.org/t/why-does-cargo-build-not-optimise-by-default/4150/3).
+
+If you compile with `cargo`, use the `--release` flag. If you compile with `rustc` directly, use the `-O` flag. Either of these will turn on optimizations.
+
+
+
+Code translation and optimizations. Rust provides high level abstractions that compile down into efficient machine code, and those translations take time to run, especially when optimizing.
+
+But Rust's compilation time is not as bad as it may seem, and there is reason to believe it will improve. When comparing projects of similar size between C++ and Rust, compilation time of the entire project is generally believed to be comparable. The common perception that Rust compilation is slow is in large part due to the differences in the *compilation model* between C++ and Rust: C++'s compilation unit is the file, while Rust's is the crate, composed of many files. Thus, during development, modifying a single C++ file can result in much less recompilation than in Rust. There is a major effort underway to refactor the compiler to introduce [incremental compilation](https://github.com/rust-lang/rfcs/blob/master/text/1298-incremental-compilation.md), which will provide Rust the compile time benefits of C++'s model.
+
+Aside from the compilation model, there are several other aspects of Rust's language design and compiler implementation that affect compile-time performance.
+
+First, Rust has a moderately-complex type system, and must spend a non-negligible amount of compile time enforcing the constraints that make Rust safe at runtime.
+
+Secondly, the Rust compiler suffers from long-standing technical debt, and notably generates poor-quality LLVM IR which LLVM must spend time "fixing." The addition of a new internal representation called [MIR](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) to the Rust compiler offers the potential to perform more optimizations and improve the quality of LLVM IR generated, but this work has not yet occured.
+
+Thirdly, Rust's use of LLVM for code generation is a double-edged sword: while it enables Rust to have world-class runtime performance, LLVM is a large framework that is not focused on compile-time performance, particularly when working with poor-quality inputs.
+
+Finally, while Rust's preferred strategy of monomorphising generics (ala C++) produces fast code, it demands that significantly more code be generated than other translation strategies. Rust programmers can use trait objects to trade away this code bloat by using dynamic dispatch instead.
+
+
+
+By default, Rust's [`HashMap`][HashMap] uses the [SipHash](https://131002.net/siphash/) hashing algorithm, which is designed to prevent [hash table collision attacks](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) while providing [reasonable performance on a variety of workloads](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6).
+
+While SipHash [demonstrates competitive performance](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in many cases, one case where it is notably slower than other hashing algorithms is with short keys, such as integers. This is why Rust programmers often observe slow performance with [`HashMap`][HashMap]. The [FNV hasher](https://crates.io/crates/fnv) is frequently recommended for these cases, but be aware that it does not have the same collision-resistance properties as SipHash.
+
+
+
+There is, but it's only available on the nightly release channel. We ultimately plan to build a pluggable system for integrated benchmarks, but in the meantime, the current system is [considered unstable](https://github.com/rust-lang/rust/issues/29553).
+
+
+
+Not generally, no. Tail-call optimization may be done in [limited circumstances](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization), but is [not guaranteed](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). As the feature has always been desired, Rust has a keyword (`become`) reserved, though it is not clear yet whether it is technically possible, nor whether it will be implemented. There was a [proposed extension](https://github.com/rust-lang/rfcs/pull/81) that would allow tail-call elimination in certain contexts, but it is currently postponed.
+
+
+
+Not in the typical sense used by languages such as Java, but parts of the Rust standard library can be considered a "runtime", providing a heap, backtraces, unwinding, and stack guards. There is a [small amount of initialization code](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) that runs before the user's `main` function. The Rust standard library additionally links to the C standard library, which does similar [runtime initialization](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). Rust code can be compiled without the standard library, in which case the runtime is roughly equivalent to C's.
+
+
+
+Use of curly braces to denote blocks is a common design choice in a variety of programming languages, and Rust's consistency is useful for people already familiar with the style.
+
+Curly braces also allow for more flexible syntax for the programmer and a simpler parser in the compiler.
+
+
+
+Whereas C requires mandatory parentheses for `if`-statement conditionals but leaves brackets optional, Rust makes the opposite choice for its `if`-expressions. This keeps the conditional clearly separate from the body and avoids the hazard of optional brackets, which can lead to easy-to-miss errors during refactoring, like Apple's [goto fail](https://gotofail.com/) bug.
+
+
+
+Rust's overall design preference is for limiting the size of the *language* while enabling powerful *libraries*. While Rust does provide initialization syntax for arrays and string literals, these are the only collection types built into the language. Other library-defined types, including the ubiquitous [`Vec`][Vec] collection type, use macros for initialization like the [`vec!`][VecMacro] macro.
+
+This design choice of using Rust's macro facilities to initialize collections will likely be extended generically to other collections in the future, enabling simple initialization of not only [`HashMap`][HashMap] and [`Vec`][Vec], but also other collection types such as [`BTreeMap`][BTreeMap]. In the meantime, if you want a more convenient syntax for initializing collections, you can [create your own macro](https://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) to provide it.
+
+
+
+Rust is a very expression-oriented language, and "implicit returns" are part of that design. Constructs like `if`s, `match`es, and normal blocks are all expressions in Rust. For example, the following code checks if an [`i64`][i64] is odd, returning the result by simply yielding it as a value:
+
+```rust
+fn is_odd(x: i64) -> bool {
+ if x % 2 != 0 { true } else { false }
+}
+```
+
+Although it can be simplified even further like so:
+
+```rust
+fn is_odd(x: i64) -> bool {
+ x % 2 != 0
+}
+```
+
+In each example, the last line of the function is the return value of that function. It is important to note that if a function ends in a semicolon, its return type will be `()`, indicating no returned value. Implicit returns must omit the semicolon to work.
+
+Explicit returns are only used if an implicit return is impossible because you are returning before the end of the function's body. While each of the above functions could have been written with a `return` keyword and semicolon, doing so would be unnecessarily verbose, and inconsistent with the conventions of Rust code.
+
+
+
+In Rust, declarations tend to come with explicit types, while actual code has its types inferred. There are several reasons for this design:
+
+- Mandatory declaration signatures help enforce interface stability at both the module and crate level.
+- Signatures improve code comprehension for the programmer, eliminating the need for an IDE running an inference algorithm across an entire crate to be able to guess at a function's argument types; it's always explicit and nearby.
+- Mechanically, it simplifies the inference algorithm, as inference only requires looking at one function at a time.
+
+
+
+To aid in refactoring and clarity.
+
+First, if every possibility is covered by the `match`, adding variants to the `enum` in the future will cause a compilation failure, rather than an error at runtime. This type of compiler assistance makes fearless refactoring possible in Rust.
+
+Second, exhaustive checking makes the semantics of the default case explicit: in general, the only safe way to have a non-exhaustive `match` would be to panic the thread if nothing is matched. Early versions of Rust did not require `match` cases to be exhaustive and it was found to be a great source of bugs.
+
+It is easy to ignore all unspecified cases by using the `_` wildcard:
+
+```rust
+match val.do_something() {
+ Cat(a) => { /* ... */ }
+ _ => { /* ... */ }
+}
+```
+
+
+
+The choice of which to use is dependent on the purpose of the program.
+
+If you are interested in the greatest degree of precision with your floating point numbers, then prefer [`f64`][f64]. If you are more interested in keeping the size of the value small or being maximally efficient, and are not concerned about the associated inaccuracy of having fewer bits per value, then [`f32`][f32] is better. Operations on [`f32`][f32] are usually faster, even on 64-bit hardware. As a common example, graphics programming typically uses [`f32`][f32] because it requires high performance, and 32-bit floats are sufficient for representing pixels on the screen.
+
+If in doubt, choose [`f64`][f64] for the greater precision.
+
+
+
+Floats can be compared with the `==`, `!=`, `<`, `<=`, `>`, and `>=` operators, and with the `partial_cmp()` function. `==` and `!=` are part of the [`PartialEq`][PartialEq] trait, while `<`, `<=`, `>`, `>=`, and `partial_cmp()` are part of the [`PartialOrd`][PartialOrd] trait.
+
+Floats cannot be compared with the `cmp()` function, which is part of the [`Ord`][Ord] trait, as there is no total ordering for floats. Furthermore, there is no total equality relation for floats, and so they also do not implement the [`Eq`][Eq] trait.
+
+There is no total ordering or equality on floats because the floating-point value [`NaN`](https://en.wikipedia.org/wiki/NaN) is not less than, greater than, or equal to any other floating-point value or itself.
+
+Because floats do not implement [`Eq`][Eq] or [`Ord`][Ord], they may not be used in types whose trait bounds require those traits, such as [`BTreeMap`][BTreeMap] or [`HashMap`][HashMap]. This is important because these types *assume* their keys provide a total ordering or total equality relation, and will malfunction otherwise.
+
+There [is a crate](https://crates.io/crates/ordered-float) that wraps [`f32`][f32] and [`f64`][f64] to provide [`Ord`][Ord] and [`Eq`][Eq] implementations, which may be useful in certain cases.
+
+
+
+There are two ways: the `as` keyword, which does simple casting for primitive types, and the [`Into`][Into] and [`From`][From] traits, which are implemented for a number of type conversions (and which you can implement for your own types). The [`Into`][Into] and [`From`][From] traits are only implemented in cases where conversions are lossless, so for example, `f64::from(0f32)` will compile while `f32::from(0f64)` will not. On the other hand, `as` will convert between any two primitive types, truncating values as necessary.
+
+
+
+
+Preincrement and postincrement (and the decrement equivalents), while convenient, are also fairly complex. They require knowledge of evaluation order, and often lead to subtle bugs and undefined behavior in C and C++. `x = x + 1` or `x += 1` is only slightly longer, but unambiguous.
+
+
+
+Usually, you can pass a reference to a `String` or `Vec` wherever a slice is expected.
+Using [Deref coercions](https://doc.rust-lang.org/stable/book/second-edition/ch15-02-deref.html), [`String`s][String] and [`Vec`s][Vec] will automatically coerce to their respective slices when passed by reference with `&` or `& mut`.
+
+Methods implemented on `&str` and `&[T]` can be accessed directly on `String` and `Vec`. For example, `some_string.char_at(0)` will work even though `char_at` is a method on `&str` and `some_string` is a `String`.
+
+In some cases, such as generic code, it's necessary to convert manually. Manual conversions can be achieved using the slicing operator, like so: `&my_vec[..]`.
+
+
+
+The [`to_string()`][to_string] method converts from a [`&str`][str] into a [`String`][String], and [`String`s][String] are automatically converted into [`&str`][str] when you borrow a reference to them. Both are demonstrated in the following example:
+
+```rust
+fn main() {
+ let s = "Jane Doe".to_string();
+ say_hello(&s);
+}
+
+fn say_hello(name: &str) {
+ println!("Hello {}!", name);
+}
+```
+
+
+
+[`String`][String] is an owned buffer of UTF-8 bytes allocated on the heap. Mutable [`String`s][String] can be modified, growing their capacity as needed. [`&str`][str] is a fixed-capacity "view" into a [`String`][String] allocated elsewhere, commonly on the heap, in the case of slices dereferenced from [`String`s][String], or in static memory, in the case of string literals.
+
+[`&str`][str] is a primitive type implemented by the Rust language, while [`String`][String] is implemented in the standard library.
+
+
+
+You cannot. At least not without a firm understanding of what you mean by "character", and preprocessing the string to find the index of the desired character.
+
+Rust strings are UTF-8 encoded. A single visual character in UTF-8 is not necessarily a single byte as it would be in an ASCII-encoded string. Each byte is called a "code unit" (in UTF-16, code units are 2 bytes; in UTF-32 they are 4 bytes). "Code points" are composed of one or more code units, and combine in "grapheme clusters" which most closely approximate characters.
+
+Thus, even though you may index on bytes in a UTF-8 string, you can't access the `i`th code point or grapheme cluster in constant time. However, if you know at which byte that desired code point or grapheme cluster begins, then you _can_ access it in constant time. Functions including [`str::find()`][str__find] and regex matches return byte indices, facilitating this sort of access.
+
+
+
+The [`str`][str] type is UTF-8 because we observe more text in the wild in this encoding – particularly in network transmissions, which are endian-agnostic – and we think it's best that the default treatment of I/O not involve having to recode codepoints in each direction.
+
+This does mean that locating a particular Unicode codepoint inside a string is an O(n) operation, although if the starting byte index is already known then they can be accessed in O(1) as expected. On the one hand, this is clearly undesirable; on the other hand, this problem is full of trade-offs and we'd like to point out a few important qualifications:
+
+Scanning a [`str`][str] for ASCII-range codepoints can still be done safely byte-at-a-time. If you use [`.as_bytes()`][str__as_bytes], pulling out a [`u8`][u8] costs only `O(1)` and produces a value that can be cast and compared to an ASCII-range [`char`][char]. So if you're (say) line-breaking on `'\n'`, byte-based treatment still works. UTF-8 was well-designed this way.
+
+Most "character oriented" operations on text only work under very restricted language assumptions such as "ASCII-range codepoints only". Outside ASCII-range, you tend to have to use a complex (non-constant-time) algorithm for determining linguistic-unit (glyph, word, paragraph) boundaries anyway. We recommend using an "honest" linguistically-aware, Unicode-approved algorithm.
+
+The [`char`][char] type is UTF-32. If you are sure you need to do a codepoint-at-a-time algorithm, it's trivial to write a `type wstr = [char]`, and unpack a [`str`][str] into it in a single pass, then work with the `wstr`. In other words: the fact that the language is not "decoding to UTF32 by default" shouldn't stop you from decoding (or re-encoding any other way) if you need to work with that encoding.
+
+For a more in-depth explanation of why UTF-8 is usually preferable over UTF-16 or UTF-32, read the [UTF-8 Everywhere manifesto](http://utf8everywhere.org/).
+
+
+
+Rust has four pairs of string types, [each serving a distinct purpose](http://www.suspectsemantics.com/blog/2016/03/27/string-types-in-rust/). In each pair, there is an "owned" string type, and a "slice" string type. The organization looks like this:
+
+| | "Slice" type | "Owned" type |
+|:--------------|:-------------|:-------------|
+| UTF-8 | `str` | `String` |
+| OS-compatible | `OsStr` | `OsString` |
+| C-compatible | `CStr` | `CString` |
+| System path | `Path` | `PathBuf` |
+
+Rust's different string types serve different purposes. `String` and `str` are UTF-8 encoded general-purpose strings. `OsString` and `OsStr` are encoded according to the current platform, and are used when interacting with the operating system. `CString` and `CStr` are the Rust equivalent of strings in C, and are used in FFI code, and `PathBuf` and `Path` are convenience wrappers around `OsString` and `OsStr`, providing methods specific to path manipulation.
+
+
+
+There are several options, depending on the needs of the function:
+
+- If the function needs an owned string, but wants to accept any type of string, use an `Into` bound.
+- If the function needs a string slice, but wants to accept any type of string, use an `AsRef` bound.
+- If the function does not care about the string type, and wants to handle the two possibilities uniformly, use `Cow` as the input type.
+
+__Using `Into`__
+
+In this example, the function will accept both owned strings and string slices, either doing nothing or converting the input into an owned string within the function body. Note that the conversion needs to be done explicitly, and will not happen otherwise.
+
+```rust
+fn accepts_both>(s: S) {
+ let s = s.into(); // This will convert s into a `String`.
+ // ... the rest of the function
+}
+```
+
+__Using `AsRef`__
+
+In this example, the function will accept both owned strings and string slices, either doing nothing or converting the input into a string slice. This can be done automatically by taking the input by reference, like so:
+
+```rust
+fn accepts_both>(s: &S) {
+ // ... the body of the function
+}
+```
+
+__Using `Cow`__
+
+In this example, the function takes in a `Cow`, which is not a generic type but a container, containing either an owned string or string slice as needed.
+
+```rust
+fn accepts_cow(s: Cow) {
+ // ... the body of the function
+}
+```
+
+
+
+
+If your reason for implementing these data structures is to use them for other programs, there's no need, as efficient implementations of these data structures are provided by the standard library.
+
+If, however, [your reason is simply to learn](http://cglab.ca/~abeinges/blah/too-many-lists/book/), then you will likely need to dip into unsafe code. While these data structures _can_ be implemented entirely in safe Rust, the performance is likely to be worse than it would be with the use of unsafe code. The simple reason for this is that data structures like vectors and linked lists rely on pointer and memory operations that are disallowed in safe Rust.
+
+For example, a doubly-linked list requires that there be two mutable references to each node, but this violates Rust's mutable reference aliasing rules. You can solve this using [`Weak`][Weak], but the performance will be poorer than you likely want. With unsafe code you can bypass the mutable reference aliasing rule restriction, but must manually verify that your code introduces no memory safety violations.
+
+
+
+The easiest way is by using the collection's [`IntoIterator`][IntoIterator] implementation. Here is an example for [`&Vec`][Vec]:
+
+```rust
+let v = vec![1,2,3,4,5];
+for item in &v {
+ print!("{} ", item);
+}
+println!("\nLength: {}", v.len());
+```
+
+Rust `for` loops call `into_iter()` (defined on the [`IntoIterator`][IntoIterator] trait) for whatever they're iterating over. Anything implementing the [`IntoIterator`][IntoIterator] trait may be looped over with a `for` loop. [`IntoIterator`][IntoIterator] is implemented for [`&Vec`][Vec] and [`&mut Vec`][Vec], causing the iterator from `into_iter()` to borrow the contents of the collection, rather than moving/consuming them. The same is true for other standard collections as well.
+
+If a moving/consuming iterator is desired, write the `for` loop without `&` or `&mut` in the iteration.
+
+If you need direct access to a borrowing iterator, you can usually get it by calling the `iter()` method.
+
+
+
+You don't necessarily have to. If you're declaring an array directly, the size is inferred based on the number of elements. But if you're declaring a function that takes a fixed-size array, the compiler has to know how big that array will be.
+
+One thing to note is that currently Rust doesn't offer generics over arrays of different size. If you'd like to accept a contiguous container of a variable number of values, use a [`Vec`][Vec] or slice (depending on whether you need ownership).
+
+
+
+There are at least four options (discussed at length in [Too Many Linked Lists](http://cglab.ca/~abeinges/blah/too-many-lists/book/)):
+
+- You can implement it using [`Rc`][Rc] and [`Weak`][Weak] to allow shared ownership of nodes,
+although this approach pays the cost of memory management.
+- You can implement it using `unsafe` code using raw pointers. This will be
+more efficient, but bypasses Rust's safety guarantees.
+- Using vectors and indices into those vectors. There are [several](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) [available](https://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html) examples and explanations of this approach.
+- Using borrowed references with [`UnsafeCell`][UnsafeCell]. There are [explanations and code](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) available for this approach.
+
+
+
+It's possible, but useless to do so. The struct becomes permanently borrowed by itself and therefore can't be moved. Here is some code illustrating this:
+
+```rust
+use std::cell::Cell;
+
+#[derive(Debug)]
+struct Unmovable<'a> {
+ x: u32,
+ y: Cell