diff --git a/README.md b/README.md
index 0c3f6098..c876c13d 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@ Embark on an exciting journey to learn and master regular expressions with **[re
 - 🇩🇪 German
 - 🇺🇦 Ukrainian
 - 🇫🇷 French
+- 🇵🇱 Polish
 - 🇰🇷 Korean [(Requested)](https://github.com/aykutkardas/regexlearn.com/issues/92)
 - 🇦🇪 Arabic [(Requested)](https://github.com/aykutkardas/regexlearn.com/issues/163)
 - 🇧🇷 Brazilian Portuguese [(Requested)](https://github.com/aykutkardas/regexlearn.com/issues/39)
diff --git a/src/localization/index.ts b/src/localization/index.ts
index 16a32e6a..aad2660a 100644
--- a/src/localization/index.ts
+++ b/src/localization/index.ts
@@ -7,6 +7,7 @@ export const langNames = {
   ru: '🇷🇺',
   'zh-cn': '🇨🇳',
   uk: '🇺🇦',
+  pl: '🇵🇱',
 };
 
 export const defaultLocale = 'en';
diff --git a/src/localization/pl/cheatsheet.json b/src/localization/pl/cheatsheet.json
new file mode 100644
index 00000000..2884ce58
--- /dev/null
+++ b/src/localization/pl/cheatsheet.json
@@ -0,0 +1,70 @@
+{
+  "cheatsheet.section.title": "Ściągawka wyrażeń regularnych",
+  "cheatsheet.section.description": "Poznaj wszystkie wzorce i symbole wyrażeń regularnych dzięki poniższej ściągawce.",
+
+  "cheatsheet.anchors": "Kotwice",
+  "cheatsheet.caret.title": "Początek napisu lub linii",
+  "cheatsheet.caret.description": "Dopasowuje początek napisu lub linii.",
+  "cheatsheet.dollar.title": "Koniec napisu lub linii",
+  "cheatsheet.dollar.description": "Dopasowuje koniec napisu lub linii.",
+  "cheatsheet.wordBoundary.title": "Granica słowa",
+  "cheatsheet.wordBoundary.description": "Dopasowuje pozycję na początku lub końcu słowa.",
+  "cheatsheet.notWordBoundary.title": "Poza granicą słowa",
+  "cheatsheet.notWordBoundary.description": "Dopasowuje pozycję, która nie znajduje się na początku lub końcu słowa.",
+
+  "cheatsheet.characterClasses": "Klasy znaków",
+  "cheatsheet.characterSet.title": "Zbiór znaków",
+  "cheatsheet.characterSet.description": "Dopasowuje dowolny znak z podanego zbioru.",
+  "cheatsheet.negatedCharacterSet.title": "Negacja zbioru znaków",
+  "cheatsheet.negatedCharacterSet.description": "Dopasowuje dowolny znak, który nie znajduje się w podanym zbiorze.",
+  "cheatsheet.range.title": "Zakres",
+  "cheatsheet.range.description": "Dopasowuje wszystkie znaki znajdujące się pomiędzy podanymi dwoma znakami, włączając w to te dwa znaki.",
+  "cheatsheet.dot.title": "Kropka",
+  "cheatsheet.dot.description": "Dopasowuje dowolny znak z wyjątkiem znaków końca linii.",
+  "cheatsheet.word.title": "Znak słowa",
+  "cheatsheet.word.description": "Dopasowuje dowolny znak alfanumeryczny będący dużą lub małą literą i podkreślnik.",
+  "cheatsheet.notWord.title": "Znak niesłowa",
+  "cheatsheet.notWord.description": "Dopasowuje dowolny znak niealfanumeryczny i inny niż podkreślnik.",
+  "cheatsheet.digit.title": "Cyfra",
+  "cheatsheet.digit.description": "Dopasowuje dowolny znak będący cyfrą.",
+  "cheatsheet.notDigit.title": "Niecyfra",
+  "cheatsheet.notDigit.description": "MDopasowuje dowolny znak niebędący cyfrą.",
+  "cheatsheet.space.title": "Biały znak",
+  "cheatsheet.space.description": "Dopasowuje dowolny biały znak.",
+  "cheatsheet.notSpace.title": "Niebiały znak",
+  "cheatsheet.notSpace.description": "Dopasowuje dowolny niebiały znak.",
+
+  "cheatsheet.flags": "Flagi",
+  "cheatsheet.caseInsensitiveFlag.title": "Ignorowanie wielkość liter",
+  "cheatsheet.caseInsensitiveFlag.description": "Sprawia, że wielkość liter w wyrażeniu nie ma znaczenia.",
+  "cheatsheet.globalFlag.title": "Wszystkie dopasowania",
+  "cheatsheet.globalFlag.description": "Gwarantuje, że wyrażenie nie zatrzyma się na pierwszym dopasowaniu.",
+  "cheatsheet.multilineFlag.title": "Tryb wieloliniowy",
+  "cheatsheet.multilineFlag.description": "Po włączeniu tej flagi początek i koniec linii jest równy początkowi i końcowi całego ciągu znaków. Nie działa dla każdego wiersza z osobna.",
+
+  "cheatsheet.groupAndReferences": "Grupy i referencje",
+  "cheatsheet.group.title": "Grupa",
+  "cheatsheet.group.description": "Grupuje wyrażenie (tworzy podwyrażenie).",
+  "cheatsheet.reference.title": "Referencja",
+  "cheatsheet.reference.description": "Wskazuje na grupę (podwyrażenie).",
+  "cheatsheet.nonCapturingGroup.title": "Grupa bez referencji",
+  "cheatsheet.nonCapturingGroup.description": "Tworzy grupę, do której nie można się odwołać.",
+
+  "cheatsheet.lookarounds": "Przewidywanie",
+  "cheatsheet.positiveLookahead.title": "Przewidywanie pozytywne w przód",
+  "cheatsheet.negativeLookahead.title": "Przewidywanie negatywne w przód",
+  "cheatsheet.positiveLookbehind.title": "Przewidywanie pozytywne wstecz",
+  "cheatsheet.negativeLookbehind.title": "Przewidywanie negatywne wstecz",
+
+  "cheatsheet.quantifiersAndAlternation": "Kwantyfikatory i alternatywa",
+  "cheatsheet.plus.title": "Plus",
+  "cheatsheet.plus.description": "Wyrażenie dopasowuje jeden znak/klasę lub więcej.",
+  "cheatsheet.asterisk.title": "Gwiazdka",
+  "cheatsheet.asterisk.description": "Wyrażenie dopasowuje zero znaków/klas lub więcej.",
+  "cheatsheet.quantifier.title": "Przedział",
+  "cheatsheet.quantifier.description": "Wyrażenie dopasowuje znak/klasę zadaną liczbę razy w podanym zakresie.",
+  "cheatsheet.optional.title": "Opcjonalność",
+  "cheatsheet.optional.description": "Sprawia, że wyrażenie jest opcjonalne.",
+  "cheatsheet.alternation.title": "Alternatywa",
+  "cheatsheet.alternation.description": "Działa jak spójnik logiczny \"lub\". Czeka na dopasowanie jednego z podanych wyrażeń."
+}
diff --git a/src/localization/pl/general.json b/src/localization/pl/general.json
new file mode 100644
index 00000000..3c1d4d02
--- /dev/null
+++ b/src/localization/pl/general.json
@@ -0,0 +1,39 @@
+{
+  "general.prev": "Wstecz",
+  "general.next": "Dalej",
+  "general.result": "Wynik",
+  "general.regex": "Regex",
+  "general.text": "Tekst",
+  "general.watch": "Obejrzyj",
+  "general.start": "Rozpocznij",
+  "general.continue": "Kontynuuj",
+  "general.completedStep": "Krok ukończony!",
+  "general.hintQuestion": "Pokaż odpowiedź",
+  "general.reportStep": "Zgłoś problem",
+  "general.startLearning": "Rozpocznij naukę",
+  "general.comingSoon": "Już wkrótce",
+  "general.becomeSponsor": "Zostań sponsorem",
+  "general.learn": "Nauka",
+  "general.playground": "Piaskownica",
+  "general.cheatsheet": "Ściągawka",
+  "general.ourSponsors": "Nasi sponsorzy",
+  "general.share": "Udostępnij",
+  "general.shareLinkCopied": "Link do udostępniania skopiowany!",
+  "general.somethingWentWrong": "Coś poszło nie tak!",
+
+  "notFound.intro": "Strona, której szukasz, nie istnieje.",
+  "notFound.button": "Wróć do strony głównej",
+
+  "page.landing.title": "RegexLearn - Krok po kroku, od zera do bohatera.",
+  "page.learn.title": "RegexLearn - Interaktywny kurs wyrażeń regularnych",
+  "page.cheatsheet.title": "RegexLearn - Ściągawka wyrażeń regularnych",
+  "page.playground.title": "RegexLearn - Piaskownica",
+  "page.404.title": "RegexLearn - Nie znaleziono strony",
+
+  "page.landing.description": "Naucz się wyrażeń regularnych interaktywnie, ćwicz na swoim poziomie wiedzy, testuj i udostępniaj własne wyrażenia regularne.",
+  "page.learn.description": "Naucz się wyrażeń regularnych krok po kroku. Ukończ interaktywny samouczek, który ułatwi i przyspieszy Twoją naukę.",
+  "page.cheatsheet.description": "Czasami trzeba po prostu zapamiętać pewne wyrażenia regularne. Sprawdź ściągawkę, która ułatwi Ci ich zrozumienie i lepsze zapamiętywanie.",
+  "page.playground.description": "Możesz łatwo tworzyć i testować wzorce wyrażeń regularnych za pomocą Piaskownicy.",
+
+  "learn.safari.unsupportWarning": "Wyrażenia regularne użyte w tym kroku nie są obsługiwane przez niektóre przeglądarki. Jeśli masz problemy z przejściem tego kroku, możesz kliknąć tutaj."
+}
diff --git a/src/localization/pl/index.js b/src/localization/pl/index.js
new file mode 100644
index 00000000..a30a668d
--- /dev/null
+++ b/src/localization/pl/index.js
@@ -0,0 +1,17 @@
+import cheatsheet from './cheatsheet.json';
+import general from './general.json';
+import landing from './landing.json';
+import learn from './learn.json';
+import lessons from './lessons.json';
+import regexForSeo from './lessons/regexForSeo.json';
+
+const messages = {
+  ...cheatsheet,
+  ...general,
+  ...landing,
+  ...learn,
+  ...lessons,
+  ...regexForSeo,
+};
+
+export default messages;
diff --git a/src/localization/pl/landing.json b/src/localization/pl/landing.json
new file mode 100644
index 00000000..e9531403
--- /dev/null
+++ b/src/localization/pl/landing.json
@@ -0,0 +1,26 @@
+{
+  "landing.title": "Naucz się wyrażeń regularnych krok po kroku, od zera do bohatera.",
+  "landing.description": "Nauka wyrażeń regularnych jest łatwiejsza, niż myślisz. Możesz używać tego narzędzia do łatwego `uczenia się`, `ćwiczeń`, `testowania` i `udostępniania` wyrażeń regularnych.",
+  "landing.imageAltText": "Ilustracja zrelaksowanego mężczyzny z położonymi nogami na stole.",
+
+  "section.learn.title": "Ucz się",
+  "section.learn.content": "`Wyrażenia regularne`, skrótowo zapisywane jako Regex lub Regexp, to ciąg znaków tworzony według zasad składni wyrażeń regularnych. Wyrażenia regularne używają poleceń takich jak wyszukiwanie, dopasowanie i edycja, przez co możesz je wykorzystać do łatwego zarządzania danymi. Regexy mogą być używane w językach programowania, np. Python, SQL, JavaScript, R, w narzędziach Google Analytics, Google Data Studio oraz w całym procesie programowania. Na stronie RegexLearn nauczysz się wyrażeń regularnych za pomocą przykładów i samouczków.",
+  "section.learn.imageAltText": "Ilustracja góry z flagą na szczycie.",
+
+  "section.cheatsheet.button": "Sprawdź teraz",
+  "section.cheatsheet.title": "Ściągawka",
+  "section.cheatsheet.content": "Dzięki `Ściągawce RegexLearn` możesz szybko sprawdzić na jednej stronie wszystkie niezbędne elementy wyrażeń regularnych. Sprawdź wszystkie wzorce i symbole wyrażeń regularnych za pomocą tej ściągawki.",
+  "section.cheatsheet.imageAltText": "Ilustracja mężczyzny przeglądającego strony przez lornetkę",
+
+  "section.playground.title": "Piaskownica",
+  "section.playground.content": "Jeśli chcesz stworzyć wyrażenie regularne, to możesz je łatwo skonstruować i przetestować za pomocą Piaskownicy. Jako tester wyrażeń regularnych możesz je zweryfikować i udostępnić innym osobom swoje do dalszej współpracy.",
+  "section.playground.imageAltText": "Ilustracja kota, który prawie strąca pełny kubek.",
+
+  "section.practice.title": "Ćwicz",
+  "section.practice.content": "Jeśli zakończyłeś część związaną z nauką, to przyszedł czas na ĆWICZENIA! W tej sekcji możesz sprawdzić swoją wiedzę o wyrażeniach regularnych i dalej ją szlifować za pomocą samouczków dostosowanych do Twojego poziomu. Już wkrótce.",
+  "section.practice.imageAltText": "Ilustracja kobiety robiącej notatki z książki.",
+
+  "section.opensource.title": "Otwarty kod",
+  "section.opensource.content": "RegexLearn to darmowy projekt otwartoźródłowy, w którym zaangażowanie społeczności w jego dalszy rozwój jest bardzo mile widziane. Praca nad tym projektem pozwala doskonalić umiejętności, uczyć się i współpracować. Możesz wesprzeć projekt tutaj.",
+  "section.opensource.imageAltText": "Ilustracja kobiety, mężczyzny i kota układających kawałki układanki."
+}
\ No newline at end of file
diff --git a/src/localization/pl/learn.json b/src/localization/pl/learn.json
new file mode 100644
index 00000000..4921e683
--- /dev/null
+++ b/src/localization/pl/learn.json
@@ -0,0 +1,164 @@
+{
+  "examples.starter.title": "Ćwiczenia",
+  "examples.starter.description": "Nadszedł czas na wykonanie kilku ćwiczeń, aby utrwalić to, czego się nauczyliśmy.",
+
+  "examples.finish.title": "Koniec ćwiczeń!",
+  "examples.finish.description": " ",
+
+  "steps.starter.title": "Wstęp",
+  "steps.starter.description": "Regex to skrót od `Regular Expression` (wyrażenie regularne). Pomaga dopasować, znaleźć lub zarządzać tekstem. Aby przejść do kolejnej sekcji i by uzyskać bardziej szczegółowy opis, wpisz `OK` w polu Regex.",
+
+  "steps.whatIsRegex.title": "Czym jest wyrażenie regularne `Regex`?",
+  "steps.whatIsRegex.description": "Wyrażenia regularne to ciągi znaków, które określają wzorzec wyszukiwania. Ich skrótowym określeniem jest `Regex` lub `Regexp`. W szczególności wykorzystuje się je do wyszukiwania lub zamiany słów w tekstach. Ponadto, dzięki nim możemy sprawdzić, czy tekst spełnia określone przez nas zasady.\\n\\n Na przykład, przyjmijmy, że masz listę nazw plików i chcesz znaleźć tylko pliki o rozszerzeniu `pdf`. Wpisując wyrażenie `^\\w+\\.pdf$` osiągniesz zamierzony efekt. Znaczenie poszczególnych elementów tego wyrażenia regularnego stanie się dla Ciebie bardziej jasne wraz z kolejnymi sekcjami tego samouczka.",
+
+  "steps.basicMatchers.title": "Podstawowe dopasowania",
+  "steps.basicMatchers.description": "Znak lub słowo, które chcemy znaleźć, wpisujemy wprost. Jest to podobne do normalnego procesu wyszukiwania. Na przykład, aby znaleźć w tekście słowo `curious`, wpisz je tak samo.",
+
+  "steps.dotCharacter.title": "Kropka `.`: dowolny znak",
+  "steps.dotCharacter.description": "Kropka `.` umożliwia wybranie dowolnego znaku, w tym znaków specjalnych i spacji. Aby kontynuować, wpisz kropkę `.` w polu Regex.",
+
+  "steps.characterSet.title": "Zbiór znaków `[abc]`",
+  "steps.characterSet.description": "Jeśli w danym wyrazie jeden ze znaków może być różnymi znakami, zapisujemy to stosując nawiasy kwadratowe `[]`, a w nim wszystkie alternatywy znaków. Na przykład, aby napisać wyrażenie, które może znaleźć wszystkie słowa w poniższym tekście, wpisz wewnątrz nawiasów kwadratowych `[]` kolejno litery `a`, `e`, `i`, `o`, `u`.",
+
+  "steps.negatedCharacterSet.title": "Negacja zbioru znaków `[^abc]`",
+  "steps.negatedCharacterSet.description": "Aby znaleźć wszystkie słowa w poniższym tekście, z wyjątkiem `ber` i `bor`, wewnątrz nawiasów kwadratowych `[]` po znaku `^` wpisz kolejno litery `e` i `o`.",
+
+  "steps.range.title": "Zakres liter `[a-z]`",
+  "steps.range.description": "Aby znaleźć litery w określonym zakresie, w nawiasach kwadratowych `[]` podaje się literę początkową i końcową oddzielone myślnikiem `-`. Wielkość liter ma znaczenie. Wpisz wyrażenie, które dopasuje wszystkie małe litery między `e` i `o`, włączając w to te litery.",
+
+  "steps.rangeNumber.title": "Zakres cyfry `[0-9]`",
+  "steps.rangeNumber.description": "Aby znaleźć cyfry w określonym zakresie, w nawiasach kwadratowych `[]` podaje się początkową i końcową cyfrę oddzielone myślnikiem `-`. Wpisz wyrażenie, które dopasuje wszystkie cyfry między `3` i `6`, włączając w to te cyfry.",
+
+  "examples.basicMatchers.title": "Ćwiczenie: podstawowe dopasowanie",
+  "examples.basicMatchers.description": "Napisz wyrażenie, które dopasuje w tekście słowo `of`.",
+
+  "examples.dotCharacter.title": "Ćwiczenie: dowolny znak",
+  "examples.dotCharacter.description": "Napisz wyrażenie, tak aby dopasować w tekście pojedyncze litery, cyfry, spacje i znaki specjalne. Wyrażenie, które wpiszesz, musi pasować do dowolnego znaku.",
+
+  "examples.characterSet.title": "Ćwiczenie: zbiór znaków",
+  "examples.characterSet.description": "Napisz wyrażenie, które dopasuje każde słowo w tekście. Jedne co się zmienia w poniższych słowach to początkowe litery.",
+
+  "examples.negatedCharacterSet.title": "Ćwiczenie: negacja zbioru znaków",
+  "examples.negatedCharacterSet.description": "Napisz wyrażenie, które w poniższym tekście będzie pasować do wszystkiego, oprócz słów `beor` i `beur`. Użyj negacji zbioru znaków.",
+
+  "examples.range.title": "Ćwiczenie: zakres liter",
+  "examples.range.description": "Napisz wyrażenie, które w poniższym tekście będzie dopasowywać litery od `g` do `k`.\\n\\nLitery `g` i `k` powinny również być uwzględnione w tym dopasowaniu.",
+
+  "examples.rangeNumber.title": "Ćwiczenie: zakres cyfr",
+  "examples.rangeNumber.description": "Napisz wyrażenie, które w poniższym tekście będzie dopasowywać cyfry od `2` do `7`.\\n\\nCyfry `2` i `7` powinny również być uwzględnione w tym dopasowaniu.",
+
+  "steps.repetitions.title": "Powtórzenia",
+  "steps.repetitions.description": "Niektóre specjalne znaki służą do określenia ile razy dany znak może powtórzyć się w tekście. Te specjalne znaki to plus `+`, gwiazdka `*` i znak zapytania `?`.",
+
+  "steps.asterisk.title": "Gwiazdka `*`",
+  "steps.asterisk.description": "Aby wskazać, że dany znak może się nie pojawić wcale lub może się pojawić wiele razy, umieszczamy po nim gwiazdkę `*`. Na przykład, możemy wskazać, że litera `e` nie powinna występować w tekście, może wystąpić raz lub więcej razy obok siebie.",
+
+  "steps.plusCharacter.title": "Plus `+`",
+  "steps.plusCharacter.description": "Aby wskazać, że dany znak może wystąpić jeden lub więcej razy, umieszczamy po nim znak plusa `+`. Na przykład, możemy wskazać, że litera `e` może wystąpić w tekście jeden lub więcej razy obok siebie.",
+
+  "steps.questionMark.title": "Znak zapytania `?`",
+  "steps.questionMark.description": "Aby wskazać, że dany znak jest opcjonalny, umieszczamy po nim znak zapytania `?`. Na przykład, możemy wskazać, że następna litera `u` jest opcjonalna.",
+
+  "steps.quantifier.title": "Nawiasy klamrowe - 1",
+  "steps.quantifier.description": "Aby określić liczbę wystąpień po sobie danego znaku, umieszczamy po nim nawiasy klamrowe `{n}` razem z liczbą określającą, ile razy ma się pojawić. Na przykład, możemy wskazać, że następna litera `e` może wystąpić obok siebie dokładnie `2` razy.",
+
+  "steps.quantifierMin.title": "Nawiasy klamrowe - 2",
+  "steps.quantifierMin.description": "Aby określić minimalną liczbę wystąpień po sobie danego znaku, wskazujemy przynajmniej ile razy ma się on pojawić, następnie przecinek `,` i umieszczamy to w nawiasach klamrowych `{n, }`. Na przykład, możemy wskazać, że litera `e` może wystąpić obok siebie przynajmniej `3` razy.",
+
+  "steps.quantifierRange.title": "Nawiasy klamrowe - 3",
+  "steps.quantifierRange.description": "Aby określić liczbę wystąpień znaku po sobie danego znaku w określonym zakresie, stosujemy nawiasy klamrowe `{x,y}` z podanym zakresem powtórzeń, który nas interesuje. Na przykład, możemy wskazać, że litera `e` może wystąpić po sobie tylko od `1` do `3` razy.",
+
+  "examples.asterisk.title": "Ćwiczenie: gwiazdka `*`",
+  "examples.asterisk.description": "Użyj gwiazdki `*` do napisania wyrażenia, które dopasuje w poniższym tekście każde słowo, w którym nie ma litery `e` lub występuje w nim co najmniej raz.",
+
+  "examples.plusCharacter.title": "Ćwiczenie: plus `+`",
+  "examples.plusCharacter.description": "Napisz wyrażenie używając znaku plus `+`, tak aby dopasować słowa, w których litera `e` występuje co najmniej raz.",
+
+  "examples.questionMark.title": "Ćwiczenie: znak zapytania `?`",
+  "examples.questionMark.description": "Napisz wyrażenie używając znaku zapytania `?`, tak aby wskazać, że litera `n` jest opcjonalna. Dzięki temu zarówno `a`, jak i `an` mogą być dopasowane.",
+
+  "examples.quantifier.title": "Ćwiczenie: nawiasy klamrowe - 1",
+  "examples.quantifier.description": "Napisz wyrażenie używając nawiasów klamrowych `{}`, które dopasuje napisy zawierające 4 cyfry obok siebie. Pamiętaj, że zakres `[0-9]` dopasowuje pojedynczą cyfrę.",
+
+  "examples.quantifierMin.title": "Ćwiczenie: nawiasy klamrowe - 2",
+  "examples.quantifierMin.description": "Napisz wyrażenie używając nawiasów klamrowych `{}`, które znajdzie napisy zawierające co najmniej `2` cyfry obok siebie.",
+
+  "examples.quantifierRange.title": "Ćwiczenie: nawiasy klamrowe - 3",
+  "examples.quantifierRange.description": "Napisz wyrażenie używając nawiasów klamrowych `{}`, które znajdzie napisy zawierające co najmniej `1` i co najwyżej `4` cyfry obok siebie.",
+
+  "steps.grouping.title": "Nawiasy okrągłe `( )`: grupowanie",
+  "steps.grouping.description": "Możemy grupować wyrażenia i używać tych grup do odwoływania się do nich lub do narzucania pewnych reguł. Aby zgrupować wyrażenie, umieszczamy je w nawiasach okrągłych `()`. W poniższym przypadku po prostu zgrupuj `haa`.",
+
+  "steps.groupReference.title": "Referencja do grupy",
+  "steps.groupReference.description": "Poniżej znajdują się zgrupowane wyrazy `ha` i `haa`. Pierwszą grupę można użyć, pisząc `\\1`, tak aby uniknąć powtarzania. W tym przypadku `1` oznacza kolejność zgrupowania. Wpisz na końcu wyrażenia `\\2`, tak aby odwołać się do drugiej grupy.",
+
+  "steps.nonCapturingGrouping.title": "Nawiasy okrągłe `(?: )`: grupowanie bez referencji",
+  "steps.nonCapturingGrouping.description": "Możesz zgrupować dane wyrażenie i zapewnić, że nie będzie możliwe odwołanie do niego przez referencję. Na przykład, poniżej znajdują się dwie grupy. Jednak odwołanie do pierwszej grupy, które oznaczamy jako `\\1`, faktycznie odnosi się do drugiej grupy, ponieważ pierwsza grupa jest grupą bez referencji.",
+
+  "steps.pipeCharacter.title": "Kreska pionowa `|`",
+  "steps.pipeCharacter.description": "Istnieje znak, który pozwala określić, że wyrażenie może znajdować się w różnych wariantach. Wszystkie możliwe wyrażenia są oddzielone znakiem pionowej kreski `|` - jest to znak alternatywy. W odróżnieniu do zbioru znaków `[abc]`, który działa na poziomie znaków, alternatywy działają na poziomie wyrażeń. Na przykład, poniższe wyrażenie dopasuje zarówno `cat`, jak i `rat`. Dodaj na końcu wyrażenia kolejny znak pionowej kreski `|` i wpisz `dog`, tak aby dopasować wszystkie słowa.",
+
+  "steps.escapeCharacter.title": "Znak ucieczki `\\`",
+  "steps.escapeCharacter.description": "Istnieją specjalne znaki, których używamy podczas pisania wyrażeń regularnych. Są to: `{ } [ ] / \\ + * . $ ^ | ?`. Aby dopasować w tekście któryś z tych znaków, musimy użyć przed nim znaku ucieczki (modyfikacji) `\\`. Na przykład, aby dopasować w tekście znaki kropki `.` i gwiazdki `*`, dodajmy przed nimi znak ucieczki `\\`.",
+
+  "steps.caret.title": "Daszek `^`:\\nDopasowanie od początku linii",
+  "steps.caret.description": "Dotychczas używaliśmy `[0-9]` do znajdowania cyfr. Aby znaleźć cyfry znajdujące się tylko na początku linii, poprzedź poniższe wyrażenie znakiem `^`.",
+
+  "steps.dollar.title": "Dolar `$`:\\nDopasowanie od końca linii",
+  "steps.dollar.description": "Dodajmy znak `$` po wartości `html`, tak aby znaleźć tylko wyrazy `html` znajdujące się na końcu linii.",
+
+  "steps.wordCharacter.title": "Znak słowa `\\w`: litera, cyfra lub podkreślnik",
+  "steps.wordCharacter.description": "Wyrażenie `\\w` służy do wyszukiwania liter, cyfr i znaków podkreślenia. Użyjmy wyrażenia `\\w`, tak aby znaleźć w tekście znaki należące do słów.",
+
+  "steps.withoutWordCharacter.title": "Znak niesłowa `\\W`",
+  "steps.withoutWordCharacter.description": "Wyrażenie `\\W` służy do wyszukiwania znaków innych niż litery, cyfry i znak podkreślenia.",
+
+  "steps.numberCharacter.title": "Cyfra `\\d`",
+  "steps.numberCharacter.description": "Wyrażenie `\\d` służy do wyszukiwania cyfr.",
+
+  "steps.withoutNumberCharacter.title": "Niecyfra `\\D`",
+  "steps.withoutNumberCharacter.description": "Wyrażenie `\\D` służy do wyszukiwania znaków innych niż cyfry.",
+
+  "steps.spaceCharacter.title": "Biały znak `\\s`",
+  "steps.spaceCharacter.description": "Wyrażenie `\\s` służy do wyszukiwania tzw. białych znaków, np. spacji, tabulacji i znaków nowej linii.",
+
+  "steps.withoutSpaceCharacter.title": "Niebiały znak `\\S`",
+  "steps.withoutSpaceCharacter.description": "Wyrażenie `\\S` służy do wyszukiwania niebiałych znaków.",
+
+  "steps.lookarounds.title": "Przewidywanie",
+  "steps.lookarounds.description": "Jeśli chcemy aby wyszukiwany przez nas tekst występował przed lub po innym tekście, musimy skorzystać z mechanizmu \"przewidywania\". W kolejnych sekcjach zobaczymy jak z niej korzystać.",
+
+  "steps.positiveLookahead.title": "Przewidywanie pozytywne w przód: `(?=)`",
+  "steps.positiveLookahead.description": "Na przykład, w poniższym tekście chcemy dopasować wartość liczbową związaną z godziną. Aby dopasować wyłącznie wartości numeryczne, po których występuje ciąg znaków `PM`, po naszym docelowym wyrażeniu musimy podać wyrażenie korzystające z przewidywania pozytywnego w przód `(?=)`. Wewnątrz nawiasów okrągłych po znaku `=` wpisz `PM`.",
+
+  "steps.negativeLookahead.title": "Przewidywanie negatywne w przód: `(?!)`",
+  "steps.negativeLookahead.description": "W kolejnym przykładzie chcemy dopasować wartość liczbową niezwiązaną z godziną. Aby dopasować wyłącznie wartości numeryczne, po których nie występuje ciąg znaków `PM`, po naszym docelowym wyrażeniu musimy podać wyrażenie korzystające z przewidywania negatywnego w przód `(?!)`. Wewnątrz nawiasów okrągłych po znaku `!` wpisz `PM`.",
+
+  "steps.positiveLookbehind.title": "Przewidywanie pozytywne wstecz: `(?<=)`",
+  "steps.positiveLookbehind.description": "W poniższym tekście chcemy dopasować wartość liczbową związaną z ceną. Aby dopasować wyłącznie wartości liczbowe, które poprzedza znak `$`, przed naszym docelowym wyrażeniem musimy podać wyrażenie korzystające z przewidywania pozytywnego wstecz `(?<=)`. Wewnątrz nawiasów okrągłych po znaku `=` wpisz `\\$`.",
+
+  "steps.negativeLookbehind.title": "Przewidywanie negatywne wstecz: `(?&lt;!)`",
+  "steps.negativeLookbehind.description": "W kolejnym przykładzie chcemy dopasować wartość liczbową niezwiązaną z ceną. Aby dopasować wyłącznie wartości liczbowe, których nie poprzedza znak `$`, przed naszym docelowym wyrażeniem musimy podać wyrażenie korzystające z przewidywania negatywnego wstecz `(?&lt;!)`. Wewnątrz nawiasów okrągłych po znaku `!` wpisz `\\$`.",
+
+  "steps.flags.title": "Flagi",
+  "steps.flags.description": "Flagi zmieniają wynik działania wyrażenia. Z tego powodu nazywane są również `modyfikatorami`. Flagi określają, czy wpisane wyrażenie traktuje tekst wejściowy jako osobne linie, czy jest wielkości liter ma znaczenie oraz czy mają zostać znalezione wszystkie możliwe dopasowania. Aby dowiedzieć się więcej o flagach, przejdź do kolejnej sekcji.", 
+  
+  "steps.flagsGlobal.title": "Wszystkie dopasowania",
+  "steps.flagsGlobal.description": "Flaga `global` (skrótowo oznaczana jako `g`) powoduje, że wyrażenie wybiera wszystkie możliwe dopasowania. Jeśli ta flaga nie jest ustawiona, to wyrażenie zwróci tylko pierwsze dopasowanie. Aby wybrać wszystkie dopasowania, włącz flagę `global`.",
+
+  "steps.flagsMultiline.title": "Tryb wieloliniowy",
+  "steps.flagsMultiline.description": "Standardowo wyrażenie regularne traktuje cały tekst jako jedną linię. Używając flagi `multiline` (skrótowo oznaczanej jako `m`), każda linia jest osobno przetwarzana przez nasze wyrażenie regularne. Dzięki temu, w poniższym przykładzie nasze wyrażenie, które ma dopasować wzorzec występujący na końcu linii, działa osobno dla każdej linii. Aby znaleźć wszystkie dopasowania, włącz flagę `multiline`.",
+
+  "steps.flagsCaseInsensitive.title": "Ignorowanie wielkość liter",
+  "steps.flagsCaseInsensitive.description": "Aby w naszym wyrażeniu wyłączyć rozróżnianie wielkości liter, musimy aktywować flagę `case-insensitive` (skrótowo oznaczaną jako `i`).",
+
+  "steps.greedyMatching.title": "Dopasowanie zachłanne",
+  "steps.greedyMatching.description": "Domyślnie wyrażenie regularne wykonuje dopasowanie zachłanne, co oznacza, że dopasowanie będzie jak najdłuższe. Spójrzmy na poniższy przykład. Mamy tu dowolne dopasowanie kończące się literą `r`, więc przed tą literą mogą wystąpić dowolne znaki. Zwróćmy uwagę, że dopasowanie nie zatrzymuje się na pierwszej napotkanej literze `r`.",
+
+  "steps.lazyMatching.title": "Dopasowanie leniwe",
+  "steps.lazyMatching.description": "Dopasowanie leniwe, w przeciwieństwie do zachłannego, zatrzymuje się przy pierwszym dopasowaniu. Na przykład, aby znaleźć w poniższym tekście pierwsze dopasowanie kończące się literą `r`, które poprzedzone jest dowolnymi znakami, w wyrażeniu regularnym po znaku `*` dodaj `?`. W konsekwencji będzie to oznaczać, że dopasowanie zakończy się na pierwszym wystąpieniu litery `r`.",
+
+  "steps.completeAllSteps.title": "Gratulacje, koniec kursu!",
+  "steps.completeAllSteps.description": "W dowolnym momencie możesz powrócić do poprzednich sekcji kursu oraz możesz łatwo poruszać się pomiędzy wszystkimi ukończonymi przez Ciebie sekcjami."
+
+}
diff --git a/src/localization/pl/lessons.json b/src/localization/pl/lessons.json
new file mode 100644
index 00000000..d7e5ae67
--- /dev/null
+++ b/src/localization/pl/lessons.json
@@ -0,0 +1,7 @@
+{
+  "lessons.regex101.title": "Regexy 101 - PL",
+  "lessons.regex101.description": "W tym przewodniku nauczysz się podstaw wyrażeń regularnych.",
+
+  "lessons.regexForSeo.title": "Regexy w SEO - PL",
+  "lessons.regexForSeo.description": "W tym przewodniku dowiesz się jak i gdzie możesz używać wyrażeń regularnych w SEO."
+}
\ No newline at end of file
diff --git a/src/localization/pl/lessons/regexForSeo.json b/src/localization/pl/lessons/regexForSeo.json
new file mode 100644
index 00000000..3603d76c
--- /dev/null
+++ b/src/localization/pl/lessons/regexForSeo.json
@@ -0,0 +1,49 @@
+{
+  "lesson.regexForSeo.starter.title": "Wyrażenia regularne w SEO",
+  "lesson.regexForSeo.starter.description": "Regexy to zbiór wyrażeń regularnych często używanych w wielu dziedzinach, zwłaszcza przez osoby pragnące zwiększyć swoją produktywność. Zalety korzystania z regexów w SEO to łatwiejsza analiza dużych zbiorów danych i tworzenie bardziej zaawansowanych filtrów. Jeśli dopiero zaczynasz przygodę z wyrażeniami regularnymi, to zalecamy rozpoczęcie od samouczka `Regex 101`. \\n\\nZacznij od wpisania `OK` w polu \"Regex\", aby przejść do kolejnej sekcji i uzyskać bardziej szczegółowe wyjaśnienia.",
+
+  "lesson.regexForSeo.usage.title": "Przykłady użycia",
+  "lesson.regexForSeo.usage.description": "Możesz używać wyrażeń regularnych w SEO na takich platformach jak `Google Analytics`, `Google Data Studio`, `Google Sheets`, `Google Search Console`, `Ahrefs`, `Deepcrawl` czy też `Screaming Frog`. Często stosuje się je również w plikach `.htaccess` i `robots.txt` (ze składnią podobną do regexów).\\n\\nPoniżej znajduje się przykładowe wyrażenie regularne, które zaznaczy na liście tylko teksty, które rozpoczynają się od `Google`.",
+
+  "lesson.regexForSeo.basics.title": "Podstawy",
+  "lesson.regexForSeo.basics.description": "Przyjrzyjmy się niektórym często używanym wyrażeniom regularnym. Zalecamy zapoznanie się z samouczkiem `Regex 101`, aby dowiedzieć się więcej na ich temat. Aby rozpocząć, wpisz `Yes`.",
+
+  "lesson.regexForSeo.or.title": "Operator \"lub\" `|`",
+  "lesson.regexForSeo.or.description": "Używamy operatora \"lub\" `|`, aby filtrować wiele wyrażeń jednocześnie. Na przykład, aby przefiltrować tekst jednocześnie pod kątem słów `seo`, jak i `regex`, należy wpisać oba słowa, oddzielając je operatorem `|`.",
+
+  "lesson.regexForSeo.optional.title": "Operator opcjonalności `?`",
+  "lesson.regexForSeo.optional.description": "Używamy go aby wskazać, że wyrażenie lub znak jest opcjonalny. Na przykład, jeśli chcemy przefiltrować tekst zawierający zarówno `http`, jak i `https`, możemy użyć operatora `|`, ale istnieje lepszy sposób dla tych dwóch prawie identycznych słów.\\n\\nW tym przykładzie litera `s` jest opcjonalna. Dodaj znak zapytania `?` na końcu litery `s`.",
+
+  "lesson.regexForSeo.any.title": "Wszystko `.*`",
+  "lesson.regexForSeo.any.description": "W wyrażeniach regularnych kropka `.` może dopasować dowolny znak, włącznie ze spacjami. Jednak dopasowanie to dotyczy tylko pojedynczego znaku. Znak gwiazdki `*` oznacza, że poprzedni element nie istnieje w ogóle lub występuje w tekście wiele razy. Gdy oba znaki są używane razem, oznacza to, że w dopasowaniu może występować element o nieograniczonej długości.\\n\\nPoniżej znajdują się różne słowa kluczowe. Dodaj `.*` na końcu wyrażenia regularnego, tak aby napisać wyrażenie, które dopasowuje tekst `how to write `&nbsp;i wszystko po nim.",
+
+  "lesson.regexForSeo.contains.title": "Zawieranie",
+  "lesson.regexForSeo.contains.description": "Aby przefiltrować tekst pod kątem danego słowa lub frazy, należy wprowadzić szukane słowo lub frazę między dwoma wyrażeniami `.*`, które dopasowują wszystko. Na przykład, wpisz `.*buy.*`, aby przefiltrować te wiersze, które zawierają `buy`.",
+
+  "lesson.regexForSeo.negated.title": "Negacja zbioru znaków `[^abc]`",
+  "lesson.regexForSeo.negated.description": "Negacji zbioru znaków `[^]` używamy by wykluczyć określone znaki. Niechciane znaki zapisujemy w nawiasach kwadratowych z daszkiem na początku. W poniższej liście występują zarówno słowa `http`, jak i `https`. Ponieważ `http` występuje w obu, wyrażenie regularne wybierze również `https`. Wpisz `[^s]` po literze `p`, aby wykluczyć literę `s`.",
+
+  "lesson.regexForSeo.caret.title": "Znak daszka `^`",
+  "lesson.regexForSeo.caret.description": "Załóżmy, że mamy listę adresów URL i chcemy znaleźć tylko te adresy URL, które zaczynają się od `http`. Adresy URL mogą zawierać ciąg znaków `http` w różnych częściach adresu, nie tylko na ich początku. Dodaj daszek `^` na początku poniższego wyrażenia, aby przefiltrować tylko te wiersze, które zaczynają się od `http`.",
+
+  "lesson.regexForSeo.dollarAndEscape.title": "Znak dolara `$` oraz znak ucieczki `\\`",
+  "lesson.regexForSeo.dollarAndEscape.description": "Znowu mamy listę adresów URL. Chcemy znaleźć tylko te adresy, które kończą się na `.htm`.\\n\\nPonieważ kropka `.` jest znakiem specjalnym dopasowującym wszystko, najpierw musimy wyłączyć jej specjalne działanie przed `htm`, używając znaku ucieczki `\\`. Operacja ta dotyczy wszystkich specjalnych znaków.\\n\\nNastępnie dodaj znak dolara `$` na końcu wyrażenia. Zapewnia to, że tekst do przefiltrowania kończy się wyrażeniem napisanym przed tym znakiem.",
+  
+  "lesson.regexForSeo.limitation.title": "Ograniczenia długości `{n}`",
+  "lesson.regexForSeo.limitation.description": "Może zdarzyć się, że chcemy przefiltrować wyniki według długości znaków. Na przykład, aby przefiltrować adresy URL o długości `35` znaków, wpisz liczbę, którą chcesz użyć jako długość, `{35}`, używając nawiasów klamrowych na końcu kropki `.`.",
+
+  "lesson.regexForSeo.maxLimitation.title": "Ograniczenia długości (maksimum) `{n,m}`",
+  "lesson.regexForSeo.maxLimitation.description": "Aby przefiltrować adresy URL o maksymalnej długości `35` znaków, wpisz `{1,35}`. Wartość minimalną i maksymalną liczby używanej jako długość podaj używając nawiasów klamrowych zaraz za kropką `.`.",
+
+  "lesson.regexForSeo.minLimitation.title": "Ograniczenia długości (minimum) `{n,}`",
+  "lesson.regexForSeo.minLimitation.description": "Aby przefiltrować adresy URL o minimalnej długości `35` znaków, wpisz za kropką `{35,}` używając nawiasów klamrowych i kończąc przecinkiem podając tylko minimalną liczbę używaną jako długość.",
+
+  "lesson.regexForSeo.robots.title": "robots.txt (składnia podobna do regexów)",
+  "lesson.regexForSeo.robots.description": "Poniżej znajduje się przykład pliku `robots.txt` zawierającego elementy podobne do wyrażeń regularnych. W przykładzie mamy, że roboty internetowe nie powinny przeszukiwać linków o rozszerzeniu `pdf`.",
+
+  "lesson.regexForSeo.htaccess.title": ".htaccess",
+  "lesson.regexForSeo.htaccess.description": "Oto przykład użycia wyrażeń regularnych w pliku `.htaccess`. Linki z rozszerzeniem `php` są przekierowywane z kodem `301` na linki z rozszerzeniem `html`.",
+
+  "lesson.regexForSeo.outro.title": "Zakończenie",
+  "lesson.regexForSeo.outro.description": "Wiedza o wyrażeniach regularnych to umiejętność, która zwiększa produktywność na dowolnej platformie, która pozwala na ich użycie. Gdy już zaczniesz z nich korzystać i będziesz szlifować umiejętność korzystania z regexów, szybciej wykonasz wielu powtarzalnych zadań i zaoszczędzisz czas na inne rzeczy. Aby lepiej zrozumieć podstawy wyrażeń regularnych, możesz odwiedzić przewodnik `Regexy 101`, gdzie możesz testować i eksperymentować z różnymi wyrażeniami. Możesz użyć `Piaskownicy` do przetestowania swoich wyrażeń regularnych na swoich tekstach."
+}