diff --git a/apps/code/app.cpp b/apps/code/app.cpp
index a640ded5a..3d554a61b 100644
--- a/apps/code/app.cpp
+++ b/apps/code/app.cpp
@@ -48,7 +48,7 @@ bool App::Snapshot::lockOnConsole() const {
 void App::Snapshot::setOpt(const char * name, char * value) {
   if (strcmp(name, "script") == 0) {
     m_scriptStore.deleteAllScripts();
-    char * separator = const_cast<char *>(UTF8Helper::CodePointSearch(value, ':'));
+    char * separator = const_cast<char *>(Ion::UTF8Helper::CodePointSearch(value, ':'));
     if (!separator) {
       return;
     }
diff --git a/apps/code/editor_controller.cpp b/apps/code/editor_controller.cpp
index 854793fc9..00f0524bb 100644
--- a/apps/code/editor_controller.cpp
+++ b/apps/code/editor_controller.cpp
@@ -70,9 +70,9 @@ bool EditorController::textAreaDidReceiveEvent(TextArea * textArea, Ion::Events:
     /* If the cursor is on the left of the text of a line, backspace one
      * indentation space at a time. */
     const char * text = textArea->text();
-    const char * firstNonSpace = UTF8Helper::NotCodePointSearch(text, ' ', true, textArea->cursorLocation());
+    const char * firstNonSpace = Ion::UTF8Helper::NotCodePointSearch(text, ' ', true, textArea->cursorLocation());
     assert(firstNonSpace >= text);
-    if (UTF8Helper::CodePointIs(firstNonSpace, '\n') && ((text - firstNonSpace)/UTF8Decoder::CharSizeOfCodePoint(' ')) >= k_indentationSpacesNumber) {
+    if (Ion::UTF8Helper::CodePointIs(firstNonSpace, '\n') && ((text - firstNonSpace)/Ion::UTF8Decoder::CharSizeOfCodePoint(' ')) >= k_indentationSpacesNumber) {
       for (int i = 0; i < k_indentationSpacesNumber; i++) {
         textArea->removeCodePoint();
       }
@@ -82,10 +82,10 @@ bool EditorController::textAreaDidReceiveEvent(TextArea * textArea, Ion::Events:
     /* If the cursor is on the left of the text of a line, a space triggers an
      * indentation. */
     const char * text = textArea->text();
-    const char * firstNonSpace = UTF8Helper::NotCodePointSearch(text, ' ', true, textArea->cursorLocation());
+    const char * firstNonSpace = Ion::UTF8Helper::NotCodePointSearch(text, ' ', true, textArea->cursorLocation());
     assert(firstNonSpace >= text);
-    if (UTF8Helper::CodePointIs(firstNonSpace, '\n')) {
-      assert(UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
+    if (Ion::UTF8Helper::CodePointIs(firstNonSpace, '\n')) {
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
       char indentationBuffer[k_indentationSpacesNumber+1];
       for (int i = 0; i < k_indentationSpacesNumber; i++) {
         indentationBuffer[i] = ' ';
diff --git a/apps/code/menu_controller.cpp b/apps/code/menu_controller.cpp
index 78adafc2f..f88f0c610 100644
--- a/apps/code/menu_controller.cpp
+++ b/apps/code/menu_controller.cpp
@@ -313,7 +313,7 @@ bool MenuController::textFieldDidFinishEditing(TextField * textField, const char
     bool foundDefaultName = Script::DefaultName(numberedDefaultName, Script::k_defaultScriptNameMaxSize);
     int defaultNameLength = strlen(numberedDefaultName);
     assert(defaultNameLength < bufferSize);
-    assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
     numberedDefaultName[defaultNameLength++] = '.';
     strlcpy(numberedDefaultName + defaultNameLength, ScriptStore::k_scriptExtension, bufferSize - defaultNameLength);
     /* If there are already scripts named script1.py, script2.py,... until
diff --git a/apps/code/python_text_area.cpp b/apps/code/python_text_area.cpp
index c7e958aab..acb84d98a 100644
--- a/apps/code/python_text_area.cpp
+++ b/apps/code/python_text_area.cpp
@@ -99,8 +99,8 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
   LOG_DRAW("Drawing \"%.*s\"\n", byteLength, text);
 
   if (!m_pythonDelegate->isPythonUser(this)) {
-    const char * lineStart = UTF8Helper::CodePointAtGlyphOffset(text, fromColumn);
-    const char * lineEnd = UTF8Helper::CodePointAtGlyphOffset(text, toColumn);
+    const char * lineStart = Ion::UTF8Helper::CodePointAtGlyphOffset(text, fromColumn);
+    const char * lineEnd = Ion::UTF8Helper::CodePointAtGlyphOffset(text, toColumn);
     drawStringAt(
       ctx,
       line,
@@ -119,8 +119,8 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
      * basis. This can work, however the MicroPython lexer won't accept a line
      * starting with a whitespace. So we're discarding leading whitespaces
      * beforehand. */
-    const char * firstNonSpace = UTF8Helper::NotCodePointSearch(text, ' ');
-    if (UTF8Helper::CodePointIs(firstNonSpace, UCodePointNull)) {
+    const char * firstNonSpace = Ion::UTF8Helper::NotCodePointSearch(text, ' ');
+    if (Ion::UTF8Helper::CodePointIs(firstNonSpace, UCodePointNull)) {
       nlr_pop();
       return;
     }
@@ -136,7 +136,7 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
       tokenLength = TokenLength(lex);
       LOG_DRAW("Draw \"%.*s\" for token %d\n", tokenLength, tokenFrom, lex->tok_kind);
       drawStringAt(ctx, line,
-        UTF8Helper::GlyphOffsetAtCodePoint(text, tokenFrom),
+        Ion::UTF8Helper::GlyphOffsetAtCodePoint(text, tokenFrom),
         tokenFrom,
         tokenLength,
         TokenColor(lex->tok_kind),
@@ -151,7 +151,7 @@ void PythonTextArea::ContentView::drawLine(KDContext * ctx, int line, const char
     if (tokenFrom < text + byteLength) {
       LOG_DRAW("Draw comment \"%.*s\" from %d\n", byteLength - (tokenFrom - text), firstNonSpace, tokenFrom);
       drawStringAt(ctx, line,
-          UTF8Helper::GlyphOffsetAtCodePoint(text, tokenFrom),
+          Ion::UTF8Helper::GlyphOffsetAtCodePoint(text, tokenFrom),
           tokenFrom,
           text + byteLength - tokenFrom,
           CommentColor,
diff --git a/apps/code/python_toolbox.cpp b/apps/code/python_toolbox.cpp
index 63b70cc20..1ee763338 100644
--- a/apps/code/python_toolbox.cpp
+++ b/apps/code/python_toolbox.cpp
@@ -330,7 +330,7 @@ bool PythonToolbox::handleEvent(Ion::Events::Event event) {
   }
   if (event.hasText() && strlen(event.text()) == 1 ) {
     char c = event.text()[0];
-    if (UTF8Helper::CodePointIsLetter(c)) {
+    if (Ion::UTF8Helper::CodePointIsLetter(c)) {
       scrollToLetter(c);
       return true;
     }
@@ -390,7 +390,7 @@ int PythonToolbox::maxNumberOfDisplayedRows() {
 }
 
 void PythonToolbox::scrollToLetter(char letter) {
-  assert(UTF8Helper::CodePointIsLetter(letter));
+  assert(Ion::UTF8Helper::CodePointIsLetter(letter));
   /* We look for a child MessageTree that starts with the wanted letter. If we
    * do not find one, we scroll to the first child MessageTree that starts with
    * a letter higher than the wanted letter. */
@@ -402,7 +402,7 @@ void PythonToolbox::scrollToLetter(char letter) {
       index = i;
       break;
     }
-    if (index < 0 && l >= lowerLetter && UTF8Helper::CodePointIsLowerCaseLetter(l)) {
+    if (index < 0 && l >= lowerLetter && Ion::UTF8Helper::CodePointIsLowerCaseLetter(l)) {
       index = i;
     }
   }
diff --git a/apps/code/script.cpp b/apps/code/script.cpp
index 12a88c976..895554e9e 100644
--- a/apps/code/script.cpp
+++ b/apps/code/script.cpp
@@ -46,9 +46,9 @@ bool Script::nameCompliant(const char * name) {
    * We do not allow upper cases in the script names because script names are
    * used in the URLs of the NumWorks workshop website and we do not want
    * problems with case sensitivity. */
-  UTF8Decoder decoder(name);
+  Ion::UTF8Decoder decoder(name);
   CodePoint c = decoder.nextCodePoint();
-  if (c == UCodePointNull || !(UTF8Helper::CodePointIsLowerCaseLetter(c) || c == '_' || c == '.')) {
+  if (c == UCodePointNull || !(Ion::UTF8Helper::CodePointIsLowerCaseLetter(c) || c == '_' || c == '.')) {
     /* The name cannot be empty. Its first letter must be in [a-z_] or the
      * extension dot. */
     return false;
@@ -57,7 +57,7 @@ bool Script::nameCompliant(const char * name) {
     if (c == '.' && strcmp(decoder.stringPosition(), ScriptStore::k_scriptExtension) == 0) {
       return true;
     }
-    if (!(UTF8Helper::CodePointIsLowerCaseLetter(c) || c == '_' || UTF8Helper::CodePointIsNumber(c))) {
+    if (!(Ion::UTF8Helper::CodePointIsLowerCaseLetter(c) || c == '_' || Ion::UTF8Helper::CodePointIsNumber(c))) {
       return false;
     }
     c = decoder.nextCodePoint();
diff --git a/apps/code/variable_box_controller.cpp b/apps/code/variable_box_controller.cpp
index 13f086a57..4735d0258 100644
--- a/apps/code/variable_box_controller.cpp
+++ b/apps/code/variable_box_controller.cpp
@@ -41,7 +41,7 @@ static bool shouldAddObject(const char * name, int maxLength) {
     return false;
   }
   assert(name != nullptr);
-  if (UTF8Helper::CodePointIs(name, '_')) {
+  if (Ion::UTF8Helper::CodePointIs(name, '_')) {
     return false;
   }
   return true;
diff --git a/apps/probability/calculation_controller.cpp b/apps/probability/calculation_controller.cpp
index 3ce66b908..6aa788001 100644
--- a/apps/probability/calculation_controller.cpp
+++ b/apps/probability/calculation_controller.cpp
@@ -298,7 +298,7 @@ void CalculationController::updateTitle() {
     if (currentChar >= k_titleBufferSize) {
       break;
     }
-    currentChar += UTF8Decoder::CodePointToChars(' ', m_titleBuffer + currentChar, k_titleBufferSize - currentChar);
+    currentChar += Ion::UTF8Decoder::CodePointToChars(' ', m_titleBuffer + currentChar, k_titleBufferSize - currentChar);
   }
   m_titleBuffer[minInt(currentChar, k_titleBufferSize) - 1] = 0;
 }
diff --git a/apps/regression/graph_controller.cpp b/apps/regression/graph_controller.cpp
index 04be6f253..4d0e0cb54 100644
--- a/apps/regression/graph_controller.cpp
+++ b/apps/regression/graph_controller.cpp
@@ -127,7 +127,7 @@ void GraphController::reloadBannerView() {
   }
   numberOfChar += strlcpy(buffer, legend, bufferSize);
   numberOfChar += PoincareHelpers::ConvertFloatToText<double>(x, buffer+numberOfChar, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::MediumNumberOfSignificantDigits), Constant::MediumNumberOfSignificantDigits);
-  assert(UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
   for (int i = numberOfChar; i < k_maxLegendLength; i++) {
     buffer[numberOfChar++] = ' ';
   }
diff --git a/apps/shared/cartesian_function.cpp b/apps/shared/cartesian_function.cpp
index b6d304e61..294f0b511 100644
--- a/apps/shared/cartesian_function.cpp
+++ b/apps/shared/cartesian_function.cpp
@@ -67,15 +67,15 @@ CartesianFunction CartesianFunction::NewModel(Ion::Storage::Record::ErrorStatus
 
 int CartesianFunction::derivativeNameWithArgument(char * buffer, size_t bufferSize, CodePoint arg) {
   // Fill buffer with f(x). Keep size for derivative sign.
-  int derivativeSize = UTF8Decoder::CharSizeOfCodePoint('\'');
+  int derivativeSize = Ion::UTF8Decoder::CharSizeOfCodePoint('\'');
   int numberOfChars = nameWithArgument(buffer, bufferSize - derivativeSize, arg);
   assert(numberOfChars + derivativeSize < bufferSize);
-  char * firstParenthesis = const_cast<char *>(UTF8Helper::CodePointSearch(buffer, '('));
-  if (!UTF8Helper::CodePointIs(firstParenthesis, '(')) {
+  char * firstParenthesis = const_cast<char *>(Ion::UTF8Helper::CodePointSearch(buffer, '('));
+  if (!Ion::UTF8Helper::CodePointIs(firstParenthesis, '(')) {
     return numberOfChars;
   }
   memmove(firstParenthesis + derivativeSize, firstParenthesis, buffer + numberOfChars - firstParenthesis);
-  UTF8Decoder::CodePointToChars('\'', firstParenthesis, derivativeSize);
+  Ion::UTF8Decoder::CodePointToChars('\'', firstParenthesis, derivativeSize);
   return numberOfChars + derivativeSize;
 }
 
diff --git a/apps/shared/function.cpp b/apps/shared/function.cpp
index bc454ed42..96356dd1f 100644
--- a/apps/shared/function.cpp
+++ b/apps/shared/function.cpp
@@ -17,9 +17,9 @@ constexpr char Function::k_parenthesedArgument[];
 bool Function::BaseNameCompliant(const char * baseName, NameNotCompliantError * error) {
   assert(baseName[0] != 0);
 
-  UTF8Decoder decoder(baseName);
+  Ion::UTF8Decoder decoder(baseName);
   CodePoint c = decoder.nextCodePoint();
-  if (UTF8Helper::CodePointIsNumber(c)) {
+  if (Ion::UTF8Helper::CodePointIsNumber(c)) {
     // The name cannot start with a number
     if (error != nullptr) {
       *error = NameNotCompliantError::NameCannotStartWithNumber;
@@ -29,9 +29,9 @@ bool Function::BaseNameCompliant(const char * baseName, NameNotCompliantError *
 
   // The name should only have allowed characters
   while (c != UCodePointNull) {
-    if (!(UTF8Helper::CodePointIsUpperCaseLetter(c)
-        || UTF8Helper::CodePointIsLowerCaseLetter(c)
-        || UTF8Helper::CodePointIsNumber(c))
+    if (!(Ion::UTF8Helper::CodePointIsUpperCaseLetter(c)
+        || Ion::UTF8Helper::CodePointIsLowerCaseLetter(c)
+        || Ion::UTF8Helper::CodePointIsNumber(c))
         || c == '_')
     {
       if (error != nullptr) {
@@ -65,13 +65,13 @@ void Function::setActive(bool active) {
 }
 
 int Function::nameWithArgument(char * buffer, size_t bufferSize, CodePoint arg) {
-  assert(UTF8Decoder::CharSizeOfCodePoint(arg) == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint(arg) == 1);
   const char * functionName = fullName();
   size_t baseNameLength = SymbolAbstract::TruncateExtension(buffer, functionName, bufferSize - k_parenthesedArgumentLength);
   int result = baseNameLength + strlcpy(&buffer[baseNameLength], k_parenthesedArgument, bufferSize-baseNameLength);
   int bufferRemainingSize = bufferSize - (baseNameLength+1);
   if (bufferRemainingSize > 0) {
-    UTF8Decoder::CodePointToChars(arg, buffer+baseNameLength+1, bufferRemainingSize);
+    Ion::UTF8Decoder::CodePointToChars(arg, buffer+baseNameLength+1, bufferRemainingSize);
   }
   return result;
 }
diff --git a/apps/shared/text_field_delegate_app.cpp b/apps/shared/text_field_delegate_app.cpp
index 720b6c0b1..57b1233d3 100644
--- a/apps/shared/text_field_delegate_app.cpp
+++ b/apps/shared/text_field_delegate_app.cpp
@@ -57,7 +57,7 @@ bool TextFieldDelegateApp::fieldDidReceiveEvent(EditableField * field, Responder
     /* TODO decode here to encode again in handleEventWithText? */
     constexpr int bufferSize = CodePoint::MaxCodePointCharLength+1;
     char buffer[bufferSize];
-    size_t length = UTF8Decoder::CodePointToChars(field->XNTCodePoint(XNT()), buffer, bufferSize);
+    size_t length = Ion::UTF8Decoder::CodePointToChars(field->XNTCodePoint(XNT()), buffer, bufferSize);
     assert(length < bufferSize - 1);
     buffer[length] = 0;
     return field->handleEventWithText(buffer);
diff --git a/apps/shared/toolbox_helpers.cpp b/apps/shared/toolbox_helpers.cpp
index 589615b89..39997e7dd 100644
--- a/apps/shared/toolbox_helpers.cpp
+++ b/apps/shared/toolbox_helpers.cpp
@@ -8,7 +8,7 @@ namespace Shared {
 namespace ToolboxHelpers {
 
 int CursorIndexInCommandText(const char * text) {
-  UTF8Decoder decoder(text);
+  Ion::UTF8Decoder decoder(text);
   size_t index = 0;
   const char * currentPointer = text;
   CodePoint codePoint = decoder.nextCodePoint();
@@ -39,7 +39,7 @@ void TextToInsertForCommandText(const char * command, char * buffer, int bufferS
   bool insideQuote = false;
   bool argumentAlreadyReplaced = false;
 
-  UTF8Decoder decoder(command);
+  Ion::UTF8Decoder decoder(command);
   CodePoint codePoint = decoder.nextCodePoint();
   while (codePoint != UCodePointNull) {
     if (codePoint == ')') {
@@ -59,10 +59,10 @@ void TextToInsertForCommandText(const char * command, char * buffer, int bufferS
       if (argumentAlreadyReplaced) {
         argumentAlreadyReplaced = false;
       }
-      index += UTF8Decoder::CodePointToChars(codePoint, buffer + index, bufferSize - index);
+      index += Ion::UTF8Decoder::CodePointToChars(codePoint, buffer + index, bufferSize - index);
     } else {
       if (replaceArgsWithEmptyChar && !argumentAlreadyReplaced) {
-        index += UTF8Decoder::CodePointToChars(UCodePointEmpty, buffer + index, bufferSize - index);
+        index += Ion::UTF8Decoder::CodePointToChars(UCodePointEmpty, buffer + index, bufferSize - index);
         argumentAlreadyReplaced = true;
       }
     }
diff --git a/apps/solver/list_controller.cpp b/apps/solver/list_controller.cpp
index bd8cb69a0..8d592d740 100644
--- a/apps/solver/list_controller.cpp
+++ b/apps/solver/list_controller.cpp
@@ -116,7 +116,7 @@ void ListController::didEnterResponderChain(Responder * previousFirstResponder)
 
 bool textRepresentsAnEquality(const char * text) {
   char equal = '=';
-  return UTF8Helper::CodePointIs(UTF8Helper::CodePointSearch(text, equal), equal);
+  return Ion::UTF8Helper::CodePointIs(Ion::UTF8Helper::CodePointSearch(text, equal), equal);
 }
 
 bool layoutRepresentsAnEquality(Poincare::Layout l) {
diff --git a/apps/statistics/box_controller.cpp b/apps/statistics/box_controller.cpp
index 5d02868a4..bc13ec0c0 100644
--- a/apps/statistics/box_controller.cpp
+++ b/apps/statistics/box_controller.cpp
@@ -51,7 +51,7 @@ void BoxController::reloadBannerView() {
   m_view.editableBannerView()->setMessageAtIndex(calculationName[selectedQuantile], 1);
 
   // Set calculation result
-  assert(UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint(' ') == 1);
   constexpr int bufferSize = PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits) + 1;
   char buffer[bufferSize];
   CalculPointer calculationMethods[5] = {&Store::minValue, &Store::firstQuartile, &Store::median, &Store::thirdQuartile,
diff --git a/apps/statistics/histogram_controller.cpp b/apps/statistics/histogram_controller.cpp
index e8dc3c9dd..291b095d7 100644
--- a/apps/statistics/histogram_controller.cpp
+++ b/apps/statistics/histogram_controller.cpp
@@ -110,18 +110,18 @@ void HistogramController::reloadBannerView() {
     numberOfChar += PoincareHelpers::ConvertFloatToText<double>(lowerBound, buffer+numberOfChar, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits);
   }
 
-  numberOfChar+= UTF8Decoder::CodePointToChars(';', buffer + numberOfChar, bufferSize - numberOfChar);
+  numberOfChar+= Ion::UTF8Decoder::CodePointToChars(';', buffer + numberOfChar, bufferSize - numberOfChar);
 
   // Add upper bound
   if (selectedSeriesIndex() >= 0) {
     double upperBound = m_store->endOfBarAtIndex(selectedSeriesIndex(), *m_selectedBarIndex);
     numberOfChar += PoincareHelpers::ConvertFloatToText<double>(upperBound, buffer+numberOfChar, PrintFloat::bufferSizeForFloatsWithPrecision(Constant::LargeNumberOfSignificantDigits), Constant::LargeNumberOfSignificantDigits);
   }
-  numberOfChar+= UTF8Decoder::CodePointToChars('[', buffer + numberOfChar, bufferSize - numberOfChar);
+  numberOfChar+= Ion::UTF8Decoder::CodePointToChars('[', buffer + numberOfChar, bufferSize - numberOfChar);
 
   // Padding
   for (int i = numberOfChar; i < k_maxIntervalLegendLength; i++) {
-    numberOfChar+= UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
+    numberOfChar+= Ion::UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
   }
   buffer[k_maxIntervalLegendLength] = 0;
   m_view.editableBannerView()->setLegendAtIndex(buffer, 1);
@@ -139,7 +139,7 @@ void HistogramController::reloadBannerView() {
   }
   // Padding
   for (int i = numberOfChar; i < k_maxLegendLength; i++) {
-    numberOfChar+= UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
+    numberOfChar+= Ion::UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
   }
   buffer[k_maxLegendLength] = 0;
   m_view.editableBannerView()->setLegendAtIndex(buffer, 3);
@@ -156,7 +156,7 @@ void HistogramController::reloadBannerView() {
   }
   // Padding
   for (int i = numberOfChar; i < k_maxLegendLength; i++) {
-    numberOfChar+= UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
+    numberOfChar+= Ion::UTF8Decoder::CodePointToChars(' ', buffer + numberOfChar, bufferSize - numberOfChar);
   }
   buffer[k_maxLegendLength] = 0;
   m_view.editableBannerView()->setLegendAtIndex(buffer, 5);
diff --git a/apps/variable_box_controller.cpp b/apps/variable_box_controller.cpp
index 13c790278..62189becf 100644
--- a/apps/variable_box_controller.cpp
+++ b/apps/variable_box_controller.cpp
@@ -200,11 +200,11 @@ bool VariableBoxController::selectLeaf(int selectedRow) {
   if (m_currentPage == Page::Function) {
     // Add parentheses to a function name
     assert(nameLength < nameToHandleMaxSize);
-    nameLength += UTF8Decoder::CodePointToChars('(', nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
+    nameLength += Ion::UTF8Decoder::CodePointToChars('(', nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
     assert(nameLength < nameToHandleMaxSize);
-    nameLength+= UTF8Decoder::CodePointToChars(UCodePointEmpty, nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
+    nameLength+= Ion::UTF8Decoder::CodePointToChars(UCodePointEmpty, nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
     assert(nameLength < nameToHandleMaxSize);
-    nameLength += UTF8Decoder::CodePointToChars(')', nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
+    nameLength += Ion::UTF8Decoder::CodePointToChars(')', nameToHandle+nameLength, nameToHandleMaxSize - nameLength);
     assert(nameLength < nameToHandleMaxSize);
     nameToHandle[nameLength] = 0;
   }
diff --git a/escher/src/text_area.cpp b/escher/src/text_area.cpp
index d8bf93d67..4854b88aa 100644
--- a/escher/src/text_area.cpp
+++ b/escher/src/text_area.cpp
@@ -24,12 +24,12 @@ static inline void InsertSpacesAtLocation(int spacesCount, char * buffer, int bu
   assert(strlen(buffer) + spacesCount < bufferSize);
 
   size_t sizeToMove = strlen(buffer) + 1;
-  size_t spaceCharSize = UTF8Decoder::CharSizeOfCodePoint(' ');
+  size_t spaceCharSize = Ion::UTF8Decoder::CharSizeOfCodePoint(' ');
   size_t spacesLength = spacesCount * spaceCharSize;
   memmove(buffer + spacesLength, buffer, sizeToMove);
   for (int i = 0; i < spacesCount; i++) {
     int spaceOffset = i * spaceCharSize;
-    UTF8Decoder::CodePointToChars(' ', buffer + spaceOffset, bufferSize - spaceOffset);
+    Ion::UTF8Decoder::CodePointToChars(' ', buffer + spaceOffset, bufferSize - spaceOffset);
   }
 }
 
@@ -44,20 +44,20 @@ bool TextArea::handleEventWithText(const char * text, bool indentation, bool for
     // Compute the indentation
     int spacesCount = indentationBeforeCursor();
     const char * teaxtAreaBuffer = contentView()->text();
-    if (cursorLocation() > teaxtAreaBuffer && UTF8Helper::PreviousCodePointIs(teaxtAreaBuffer, cursorLocation(), ':')) {
+    if (cursorLocation() > teaxtAreaBuffer && Ion::UTF8Helper::PreviousCodePointIs(teaxtAreaBuffer, cursorLocation(), ':')) {
       spacesCount += k_indentationSpaces;
     }
 
     // Check the text will not overflow the buffer
-    int totalIndentationSize = UTF8Helper::CountOccurrences(text, '\n') * spacesCount;
+    int totalIndentationSize = Ion::UTF8Helper::CountOccurrences(text, '\n') * spacesCount;
     if (contentView()->getText()->textLength() + textLength + totalIndentationSize >= contentView()->getText()->bufferSize() || textLength == 0) {
       return false;
     }
 
-    UTF8Helper::PerformAtCodePoints(
+    Ion::UTF8Helper::PerformAtCodePoints(
         buffer, '\n',
         [](int codePointOffset, void * text, int indentation) {
-          int offset = codePointOffset + UTF8Decoder::CharSizeOfCodePoint('\n');
+          int offset = codePointOffset + Ion::UTF8Decoder::CharSizeOfCodePoint('\n');
           InsertSpacesAtLocation(indentation, (char *)text + offset, TextField::maxBufferSize() - offset); //TODO
         },
         [](int c1, void * c2, int c3) {},
@@ -67,7 +67,7 @@ bool TextArea::handleEventWithText(const char * text, bool indentation, bool for
   const char * cursorPositionInCommand = TextInputHelpers::CursorPositionInCommand(buffer);
 
   // Remove the Empty code points
-  UTF8Helper::RemoveCodePoint(buffer, UCodePointEmpty, &cursorPositionInCommand);
+  Ion::UTF8Helper::RemoveCodePoint(buffer, UCodePointEmpty, &cursorPositionInCommand);
 
   // Insert the text
   if (insertTextAtLocation(buffer, cursorLocation())) {
@@ -88,14 +88,14 @@ bool TextArea::handleEvent(Ion::Events::Event event) {
       assert(cursorLocation() == text());
       return false;
     }
-    UTF8Decoder decoder(text(), cursorLocation());
+    Ion::UTF8Decoder decoder(text(), cursorLocation());
     decoder.previousCodePoint();
     return setCursorLocation(decoder.stringPosition());
   } else if (event == Ion::Events::Right) {
-    if (UTF8Helper::CodePointIs(cursorLocation(), UCodePointNull)) {
+    if (Ion::UTF8Helper::CodePointIs(cursorLocation(), UCodePointNull)) {
       return false;
     }
-    UTF8Decoder decoder(cursorLocation());
+    Ion::UTF8Decoder decoder(cursorLocation());
     decoder.nextCodePoint();
     return setCursorLocation(decoder.stringPosition());
   } else if (event == Ion::Events::Up) {
@@ -135,7 +135,7 @@ int TextArea::indentationBeforeCursor() const {
   /* Compute the number of spaces at the beginning of the line. Increase the
    * indentation size when encountering spaces, reset it to 0 when encountering
    * another code point, until reaching the beginning of the line. */
-  UTF8Helper::PerformAtCodePoints(const_cast<TextArea *>(this)->contentView()->text(), ' ',
+  Ion::UTF8Helper::PerformAtCodePoints(const_cast<TextArea *>(this)->contentView()->text(), ' ',
       [](int codePointOffset, void * indentationSize, int context){
         int * castedSize = (int *) indentationSize;
         *castedSize = *castedSize + 1;
@@ -157,7 +157,7 @@ const char * TextArea::Text::pointerAtPosition(Position p) {
   int y = 0;
   for (Line l : *this) {
     if (p.line() == y) {
-      const char * result = UTF8Helper::CodePointAtGlyphOffset(l.text(), p.column());
+      const char * result = Ion::UTF8Helper::CodePointAtGlyphOffset(l.text(), p.column());
       return minPointer(result, l.text() + l.charLength());
     }
     y++;
@@ -171,7 +171,7 @@ TextArea::Text::Position TextArea::Text::positionAtPointer(const char * p) const
   size_t y = 0;
   for (Line l : *this) {
     if (l.contains(p)) {
-      size_t x = UTF8Helper::GlyphOffsetAtCodePoint(l.text(), p);
+      size_t x = Ion::UTF8Helper::GlyphOffsetAtCodePoint(l.text(), p);
       return Position(x, y);
     }
     y++;
@@ -197,12 +197,12 @@ void TextArea::Text::insertSpacesAtLocation(int numberOfSpaces, char * location)
   assert(strlen(m_buffer) + numberOfSpaces < m_bufferSize);
 
   size_t sizeToMove = strlen(location) + 1;
-  size_t spaceCharSize = UTF8Decoder::CharSizeOfCodePoint(' ');
+  size_t spaceCharSize = Ion::UTF8Decoder::CharSizeOfCodePoint(' ');
   size_t spacesSize = numberOfSpaces * spaceCharSize;
   assert(location + spacesSize + sizeToMove <= m_buffer + m_bufferSize);
   memmove(location + spacesSize, location, sizeToMove);
   for (int i = 0; i < numberOfSpaces; i++) {
-    UTF8Decoder::CodePointToChars(' ', location+i*spaceCharSize, (m_buffer + m_bufferSize) - location);
+    Ion::UTF8Decoder::CodePointToChars(' ', location+i*spaceCharSize, (m_buffer + m_bufferSize) - location);
   }
 }
 
@@ -211,7 +211,7 @@ CodePoint TextArea::Text::removeCodePoint(char * * position) {
   assert(m_buffer <= *position && *position < m_buffer + m_bufferSize);
 
   CodePoint removedCodePoint = 0;
-  int removedSize = UTF8Helper::RemovePreviousCodePoint(m_buffer, *position, &removedCodePoint);
+  int removedSize = Ion::UTF8Helper::RemovePreviousCodePoint(m_buffer, *position, &removedCodePoint);
   assert(removedSize > 0);
 
   // Set the new cursor position
@@ -225,7 +225,7 @@ size_t TextArea::Text::removeRemainingLine(const char * location, int direction)
   assert(direction > 0 || location > m_buffer);
   assert(direction < 0 || location < m_buffer + m_bufferSize);
 
-  UTF8Decoder decoder(m_buffer, location);
+  Ion::UTF8Decoder decoder(m_buffer, location);
   const char * codePointPosition = decoder.stringPosition();
   CodePoint nextCodePoint = direction > 0 ? decoder.nextCodePoint() : decoder.previousCodePoint();
   if (direction < 0) {
@@ -271,7 +271,7 @@ TextArea::Text::Line::Line(const char * text) :
   m_charLength(0)
 {
   if (m_text != nullptr) {
-    m_charLength = UTF8Helper::CodePointSearch(text, '\n') - m_text;
+    m_charLength = Ion::UTF8Helper::CodePointSearch(text, '\n') - m_text;
   }
 }
 
@@ -283,17 +283,17 @@ bool TextArea::Text::Line::contains(const char * c) const {
   return (c >= m_text)
     && ((c < m_text + m_charLength)
         || (c == m_text + m_charLength
-          && (UTF8Helper::CodePointIs(c, 0)
-            || UTF8Helper::CodePointIs(c, '\n')))) ;
+          && (Ion::UTF8Helper::CodePointIs(c, 0)
+            || Ion::UTF8Helper::CodePointIs(c, '\n')))) ;
 }
 
 /* TextArea::Text::LineIterator */
 
 TextArea::Text::LineIterator & TextArea::Text::LineIterator::operator++() {
   const char * last = m_line.text() + m_line.charLength();
-  assert(UTF8Helper::CodePointIs(last, 0) || UTF8Helper::CodePointIs(last, '\n'));
-  assert(UTF8Decoder::CharSizeOfCodePoint('\n') == 1);
-  m_line = Line(UTF8Helper::CodePointIs(last, 0) ? nullptr : last + 1);
+  assert(Ion::UTF8Helper::CodePointIs(last, 0) || Ion::UTF8Helper::CodePointIs(last, '\n'));
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint('\n') == 1);
+  m_line = Line(Ion::UTF8Helper::CodePointIs(last, 0) ? nullptr : last + 1);
   return *this;
 }
 
@@ -378,7 +378,7 @@ bool TextArea::TextArea::ContentView::insertTextAtLocation(const char * text, co
   bool lineBreak = false;
 
   // Scan for \n and 0
-  const char * nullLocation = UTF8Helper::PerformAtCodePoints(
+  const char * nullLocation = Ion::UTF8Helper::PerformAtCodePoints(
       text, '\n',
       [](int codePointOffset, void * lineBreak, int indentation) {
         *((bool *)lineBreak) = true;
@@ -386,7 +386,7 @@ bool TextArea::TextArea::ContentView::insertTextAtLocation(const char * text, co
       [](int c1, void * c2, int c3) { },
       &lineBreak, 0);
 
-  assert(UTF8Helper::CodePointIs(nullLocation, 0));
+  assert(Ion::UTF8Helper::CodePointIs(nullLocation, 0));
   m_text.insertText(text, nullLocation - text, const_cast<char *>(location));
   reloadRectFromPosition(location, lineBreak);
   return true;
diff --git a/escher/src/text_field.cpp b/escher/src/text_field.cpp
index 6b87cb0d5..551a2ae5d 100644
--- a/escher/src/text_field.cpp
+++ b/escher/src/text_field.cpp
@@ -115,14 +115,14 @@ bool TextField::ContentView::insertTextAtLocation(const char * text, const char
   *overridenByteLocation = overridenByte;
   m_currentDraftTextLength += textSize;
 
-  UTF8Decoder decoder(m_draftTextBuffer);
+  Ion::UTF8Decoder decoder(m_draftTextBuffer);
   const char * codePointPointer = decoder.stringPosition();
   CodePoint codePoint = decoder.nextCodePoint();
   assert(!codePoint.isCombining());
   while (codePoint != UCodePointNull) {
     assert(codePointPointer < m_draftTextBuffer + m_textBufferSize);
     if (codePoint == '\n') {
-      assert(UTF8Decoder::CharSizeOfCodePoint('\n') == 1);
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint('\n') == 1);
       *(const_cast<char *>(codePointPointer)) = 0;
       m_currentDraftTextLength = codePointPointer - m_draftTextBuffer;
       break;
@@ -154,7 +154,7 @@ bool TextField::ContentView::removeCodePoint() {
   }
   // Remove the code point if possible
   CodePoint removedCodePoint = 0;
-  int removedSize = UTF8Helper::RemovePreviousCodePoint(m_draftTextBuffer, const_cast<char *>(cursorLocation()), &removedCodePoint);
+  int removedSize = Ion::UTF8Helper::RemovePreviousCodePoint(m_draftTextBuffer, const_cast<char *>(cursorLocation()), &removedCodePoint);
   if (removedSize == 0) {
     assert(cursorLocation() == m_draftTextBuffer);
     return false;
@@ -360,7 +360,7 @@ CodePoint TextField::XNTCodePoint(CodePoint defaultXNTCodePoint) {
    * reasonable if the expression is being entered left-to-right. */
   const char * text = this->text();
   const char * location = cursorLocation();
-  UTF8Decoder decoder(text, text + (location - m_contentView.draftTextBuffer()));
+  Ion::UTF8Decoder decoder(text, text + (location - m_contentView.draftTextBuffer()));
   unsigned level = 0;
   while (location > m_contentView.draftTextBuffer()) {
     CodePoint c = decoder.previousCodePoint();
@@ -433,7 +433,7 @@ void TextField::scrollToCursor() {
 bool TextField::privateHandleMoveEvent(Ion::Events::Event event) {
   if (event == Ion::Events::Left && isEditing() && cursorLocation() > m_contentView.draftTextBuffer()) {
     assert(isEditing());
-    UTF8Decoder decoder(m_contentView.draftTextBuffer(), cursorLocation());
+    Ion::UTF8Decoder decoder(m_contentView.draftTextBuffer(), cursorLocation());
     decoder.previousCodePoint();
     return setCursorLocation(decoder.stringPosition());
   }
@@ -443,7 +443,7 @@ bool TextField::privateHandleMoveEvent(Ion::Events::Event event) {
   }
   if (event == Ion::Events::Right && isEditing() && cursorLocation() < m_contentView.draftTextBuffer() + draftTextLength()) {
     assert(isEditing());
-    UTF8Decoder decoder(cursorLocation());
+    Ion::UTF8Decoder decoder(cursorLocation());
     decoder.nextCodePoint();
     return setCursorLocation(decoder.stringPosition());
   }
@@ -473,7 +473,7 @@ bool TextField::handleEventWithText(const char * eventText, bool indentation, bo
   // Remove the Empty code points
   constexpr int bufferSize = TextField::maxBufferSize();
   char buffer[bufferSize];
-  UTF8Helper::CopyAndRemoveCodePoint(buffer, bufferSize, eventText, UCodePointEmpty);
+  Ion::UTF8Helper::CopyAndRemoveCodePoint(buffer, bufferSize, eventText, UCodePointEmpty);
 
   const char * nextCursorLocation = m_contentView.draftTextBuffer() + draftTextLength();
   if (insertTextAtLocation(buffer, cursorLocation())) {
diff --git a/escher/src/text_input_helpers.cpp b/escher/src/text_input_helpers.cpp
index e0801444b..6eef1e9ed 100644
--- a/escher/src/text_input_helpers.cpp
+++ b/escher/src/text_input_helpers.cpp
@@ -5,7 +5,7 @@
 namespace TextInputHelpers {
 
 const char * CursorPositionInCommand(const char * text) {
-  UTF8Decoder decoder(text);
+  Ion::UTF8Decoder decoder(text);
   const char * currentPointer = text;
   CodePoint codePoint = decoder.nextCodePoint();
   while (codePoint != UCodePointNull) {
diff --git a/ion/include/ion/unicode/utf8_decoder.h b/ion/include/ion/unicode/utf8_decoder.h
index 432b5c072..103f4eb92 100644
--- a/ion/include/ion/unicode/utf8_decoder.h
+++ b/ion/include/ion/unicode/utf8_decoder.h
@@ -28,6 +28,8 @@
  *     glyphs such as accentuated letters.
  */
 
+namespace Ion {
+
 class UTF8Decoder {
 public:
   UTF8Decoder(const char * string, const char * initialPosition = nullptr) :
@@ -46,4 +48,6 @@ private:
   const char * m_stringPosition;
 };
 
+}
+
 #endif
diff --git a/ion/include/ion/unicode/utf8_helper.h b/ion/include/ion/unicode/utf8_helper.h
index 2a665f25c..fdc7f9646 100644
--- a/ion/include/ion/unicode/utf8_helper.h
+++ b/ion/include/ion/unicode/utf8_helper.h
@@ -4,6 +4,8 @@
 #include "code_point.h"
 #include <stddef.h>
 
+namespace Ion {
+
 namespace UTF8Helper {
 
 // Returns the number of occurences of a code point in a string
@@ -70,4 +72,6 @@ size_t GlyphOffsetAtCodePoint(const char * buffer, const char * position);
 
 };
 
+}
+
 #endif
diff --git a/ion/src/shared/unicode/utf8_decoder.cpp b/ion/src/shared/unicode/utf8_decoder.cpp
index af0d59d46..d6d1f24d3 100644
--- a/ion/src/shared/unicode/utf8_decoder.cpp
+++ b/ion/src/shared/unicode/utf8_decoder.cpp
@@ -1,6 +1,8 @@
 #include <ion/unicode/utf8_decoder.h>
 #include <assert.h>
 
+namespace Ion {
+
 static inline int leading_ones(uint8_t value) {
   for (int i=0; i<8; i++) {
     if (!(value & 0x80)) {
@@ -107,3 +109,5 @@ size_t UTF8Decoder::CodePointToChars(CodePoint c, char * buffer, size_t bufferSi
   assert(i == charCount);
   return charCount;
 }
+
+}
\ No newline at end of file
diff --git a/ion/src/shared/unicode/utf8_helper.cpp b/ion/src/shared/unicode/utf8_helper.cpp
index 51a8bf3ac..68c69be3a 100644
--- a/ion/src/shared/unicode/utf8_helper.cpp
+++ b/ion/src/shared/unicode/utf8_helper.cpp
@@ -3,6 +3,8 @@
 #include <string.h>
 #include <assert.h>
 
+namespace Ion {
+
 namespace UTF8Helper {
 
 static inline int minInt(int x, int y) { return x < y ? x : y; }
@@ -327,4 +329,6 @@ size_t GlyphOffsetAtCodePoint(const char * buffer, const char * position) {
 }
 
 
-};
+}
+
+}
diff --git a/ion/test/utf8_decoder.cpp b/ion/test/utf8_decoder.cpp
index 26248502a..8c67b241c 100644
--- a/ion/test/utf8_decoder.cpp
+++ b/ion/test/utf8_decoder.cpp
@@ -2,13 +2,13 @@
 #include <ion/unicode/utf8_decoder.h>
 
 void assert_decodes_to(const char * string, CodePoint c) {
-  UTF8Decoder d(string);
+  Ion::UTF8Decoder d(string);
   quiz_assert(d.nextCodePoint() == c);
   quiz_assert(d.nextCodePoint() == 0);
 }
 
 void assert_previous_code_point_is_to(const char * string, const char * stringPosition, CodePoint c) {
-  UTF8Decoder d(string, stringPosition);
+  Ion::UTF8Decoder d(string, stringPosition);
   quiz_assert(d.previousCodePoint() == c);
 }
 
diff --git a/kandinsky/src/context_text.cpp b/kandinsky/src/context_text.cpp
index 49de92fe7..dce5e9b3c 100644
--- a/kandinsky/src/context_text.cpp
+++ b/kandinsky/src/context_text.cpp
@@ -12,7 +12,7 @@ KDPoint KDContext::drawString(const char * text, KDPoint p, const KDFont * font,
 
   KDFont::GlyphBuffer glyphBuffer;
 
-  UTF8Decoder decoder(text);
+  Ion::UTF8Decoder decoder(text);
   const char * codePointPointer = decoder.stringPosition();
   CodePoint codePoint = decoder.nextCodePoint();
   while (codePoint != UCodePointNull && (maxByteLength < 0 || codePointPointer < text + maxByteLength)) {
diff --git a/kandinsky/src/font.cpp b/kandinsky/src/font.cpp
index 80d3b9896..5536e793f 100644
--- a/kandinsky/src/font.cpp
+++ b/kandinsky/src/font.cpp
@@ -12,7 +12,7 @@ KDSize KDFont::stringSizeUntil(const char * text, const char * limit) const {
   }
   KDSize stringSize = KDSize(0, m_glyphSize.height());
 
-  UTF8Decoder decoder(text);
+  Ion::UTF8Decoder decoder(text);
   const char * currentStringPosition = decoder.stringPosition();
   CodePoint codePoint = decoder.nextCodePoint();
   while (codePoint != UCodePointNull && (limit == nullptr || currentStringPosition < limit)) {
diff --git a/poincare/src/constant.cpp b/poincare/src/constant.cpp
index fc133768e..386e822ee 100644
--- a/poincare/src/constant.cpp
+++ b/poincare/src/constant.cpp
@@ -44,7 +44,7 @@ int rankOfConstant(CodePoint c) {
 }
 
 CodePoint ConstantNode::codePoint() const {
-  UTF8Decoder decoder = UTF8Decoder(m_name);
+  Ion::UTF8Decoder decoder = Ion::UTF8Decoder(m_name);
   CodePoint result = decoder.nextCodePoint();
   assert(decoder.nextCodePoint() == UCodePointNull);
   return result;
@@ -86,7 +86,7 @@ Expression ConstantNode::shallowReduce(Context & context, Preferences::ComplexFo
 }
 
 bool ConstantNode::isConstantCodePoint(CodePoint c) const {
-  UTF8Decoder decoder(m_name);
+  Ion::UTF8Decoder decoder(m_name);
   bool result = (decoder.nextCodePoint() == c);
   assert(decoder.nextCodePoint() == UCodePointNull);
   return result;
diff --git a/poincare/src/decimal.cpp b/poincare/src/decimal.cpp
index 812b5cdf7..0282c99a5 100644
--- a/poincare/src/decimal.cpp
+++ b/poincare/src/decimal.cpp
@@ -143,7 +143,7 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print
 
   // Assert that m is not +/-inf
   assert(strcmp(tempBuffer, Infinity::Name()) != 0);
-  assert(!(UTF8Helper::CodePointIs(tempBuffer, '-') && strcmp(&tempBuffer[1], Infinity::Name()) == 0));
+  assert(!(Ion::UTF8Helper::CodePointIs(tempBuffer, '-') && strcmp(&tempBuffer[1], Infinity::Name()) == 0));
 
   if (strcmp(tempBuffer, Undefined::Name()) == 0) {
     currentChar += strlcpy(buffer+currentChar, tempBuffer, bufferSize-currentChar);
@@ -176,12 +176,12 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print
        * We should use the UTF8Helper to manipulate chars, but it is clearer to
        * manipulate chars directly, so we just put assumptions on the char size
        * of the code points we manipuate. */
-      assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
       currentChar++;
       if (currentChar >= bufferSize-1) { return bufferSize-1; }
       int decimalMarkerPosition = currentChar;
       currentChar += strlcpy(buffer+currentChar, tempBuffer, bufferSize-currentChar);
-      assert(UTF8Decoder::CharSizeOfCodePoint(buffer[decimalMarkerPosition]) == 1);
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint(buffer[decimalMarkerPosition]) == 1);
       buffer[decimalMarkerPosition-1] = buffer[decimalMarkerPosition];
       buffer[decimalMarkerPosition] = '.';
     }
@@ -195,8 +195,8 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print
     return currentChar;
   }
   /* Case 1: Decimal mode */
-  assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
-  assert(UTF8Decoder::CharSizeOfCodePoint('0') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint('0') == 1);
   int deltaCharMantissa = exponent < 0 ? -exponent+1 : 0;
   strlcpy(buffer+currentChar+deltaCharMantissa, tempBuffer, maxInt(0, bufferSize-deltaCharMantissa-currentChar));
   if (exponent < 0) {
@@ -213,7 +213,7 @@ int DecimalNode::convertToText(char * buffer, int bufferSize, Preferences::Print
       buffer[i+1] = buffer[i];
     }
     if (currentChar >= bufferSize-1) { return bufferSize-1; }
-    assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
     buffer[decimalMarkerPosition+1] = '.';
     currentChar++;
   }
@@ -237,7 +237,7 @@ template<typename T> T DecimalNode::templatedApproximate() const {
 }
 
 int Decimal::Exponent(const char * integralPart, int integralPartLength, const char * fractionalPart, int fractionalPartLength, const char * exponent, int exponentLength, bool exponentNegative) {
-  if (exponentLength > 0 && UTF8Helper::CodePointIs(exponent, '-')) {
+  if (exponentLength > 0 && Ion::UTF8Helper::CodePointIs(exponent, '-')) {
     exponent++;
     exponentNegative = true;
     exponentLength--;
@@ -263,7 +263,7 @@ int Decimal::Exponent(const char * integralPart, int integralPartLength, const c
   if (integralPart == integralPartEnd) {
     const char * fractionalPartEnd = fractionalPart + fractionalPartLength;
     if (fractionalPart != nullptr) {
-      while (UTF8Helper::CodePointIs(fractionalPart, '0') && fractionalPart < fractionalPartEnd) {
+      while (Ion::UTF8Helper::CodePointIs(fractionalPart, '0') && fractionalPart < fractionalPartEnd) {
         fractionalPart++;
         exp--;
       }
@@ -281,7 +281,7 @@ Decimal Decimal::Builder(const char * integralPart, int integralPartLength, cons
   Integer zero(0);
   Integer base(10);
   // Get rid of useless preceeding 0s
-  while (UTF8Helper::CodePointIs(integralPart, '0') && integralPartLength > 1) {
+  while (Ion::UTF8Helper::CodePointIs(integralPart, '0') && integralPartLength > 1) {
     integralPart++;
     integralPartLength--;
   }
@@ -292,9 +292,9 @@ Decimal Decimal::Builder(const char * integralPart, int integralPartLength, cons
   Integer numerator(integralPart, integralPartLength, false);
   assert(!numerator.isOverflow());
   // Special case for 0.??? : get rid of useless 0s in front of the integralPartLength
-  if (fractionalPart != nullptr && integralPartLength == 1 && UTF8Helper::CodePointIs(integralPart, '0')) {
+  if (fractionalPart != nullptr && integralPartLength == 1 && Ion::UTF8Helper::CodePointIs(integralPart, '0')) {
     integralPartLength = 0;
-    while (UTF8Helper::CodePointIs(fractionalPart, '0')) {
+    while (Ion::UTF8Helper::CodePointIs(fractionalPart, '0')) {
       fractionalPart++;
       fractionalPartLength--;
     }
diff --git a/poincare/src/expression.cpp b/poincare/src/expression.cpp
index 3a0e65b85..3919c76b3 100644
--- a/poincare/src/expression.cpp
+++ b/poincare/src/expression.cpp
@@ -359,7 +359,7 @@ void Expression::SetEncounteredComplex(bool encounterComplex) {
 }
 
 Preferences::ComplexFormat Expression::UpdatedComplexFormatWithTextInput(Preferences::ComplexFormat complexFormat, const char * textInput) {
-  if (complexFormat == Preferences::ComplexFormat::Real && *(UTF8Helper::CodePointSearch(textInput, UCodePointMathematicalBoldSmallI)) != 0) {
+  if (complexFormat == Preferences::ComplexFormat::Real && *(Ion::UTF8Helper::CodePointSearch(textInput, UCodePointMathematicalBoldSmallI)) != 0) {
     return Preferences::ComplexFormat::Cartesian;
   }
   return complexFormat;
diff --git a/poincare/src/expression_debug.cpp b/poincare/src/expression_debug.cpp
index cf56a96c8..c4115714e 100644
--- a/poincare/src/expression_debug.cpp
+++ b/poincare/src/expression_debug.cpp
@@ -213,7 +213,7 @@ void print_expression(const Expression e, int indentationLevel) {
       break;
     case ExpressionNode::Type::Symbol:
       std::cout << "Symbol(";
-      UTF8Decoder decoder(static_cast<const Symbol &>(e).name());
+      Ion::UTF8Decoder decoder(static_cast<const Symbol &>(e).name());
       CodePoint firstCodePoint = decoder.nextCodePoint();
       switch (firstCodePoint) {
         case UCodePointGreekSmallLetterPi:
diff --git a/poincare/src/integer.cpp b/poincare/src/integer.cpp
index a28e19e0b..beaaa0e19 100644
--- a/poincare/src/integer.cpp
+++ b/poincare/src/integer.cpp
@@ -139,7 +139,7 @@ Integer::Integer(double_native_int_t i) {
 Integer::Integer(const char * digits, size_t length, bool negative) :
   Integer(0)
 {
-  if (digits != nullptr && UTF8Helper::CodePointIs(digits, '-')) {
+  if (digits != nullptr && Ion::UTF8Helper::CodePointIs(digits, '-')) {
     negative = true;
     digits++;
     length--;
@@ -208,8 +208,8 @@ Layout Integer::createLayout() const {
   char buffer[k_maxNumberOfDigitsBase10];
   int numberOfChars = serialize(buffer, k_maxNumberOfDigitsBase10);
   assert(numberOfChars >= 1);
-  if ((int)UTF8Decoder::CharSizeOfCodePoint(buffer[0]) == numberOfChars) {
-    UTF8Decoder decoder = UTF8Decoder(buffer);
+  if ((int)Ion::UTF8Decoder::CharSizeOfCodePoint(buffer[0]) == numberOfChars) {
+    Ion::UTF8Decoder decoder = Ion::UTF8Decoder(buffer);
     return CodePointLayout::Builder(decoder.nextCodePoint());
   }
   return LayoutHelper::String(buffer, numberOfChars);
diff --git a/poincare/src/layout_cursor.cpp b/poincare/src/layout_cursor.cpp
index 686405c13..21f1a367b 100644
--- a/poincare/src/layout_cursor.cpp
+++ b/poincare/src/layout_cursor.cpp
@@ -141,7 +141,7 @@ void LayoutCursor::addXNTCodePointLayout() {
 void LayoutCursor::insertText(const char * text) {
   Layout newChild;
   Layout pointedChild;
-  UTF8Decoder decoder(text);
+  Ion::UTF8Decoder decoder(text);
   CodePoint codePoint = decoder.nextCodePoint();
   if (codePoint == UCodePointNull) {
     return;
diff --git a/poincare/src/layout_helper.cpp b/poincare/src/layout_helper.cpp
index c5f989c62..5c928401c 100644
--- a/poincare/src/layout_helper.cpp
+++ b/poincare/src/layout_helper.cpp
@@ -57,7 +57,7 @@ Layout LayoutHelper::Parentheses(Layout layout, bool cloneLayout) {
 HorizontalLayout LayoutHelper::String(const char * buffer, int bufferLen, const KDFont * font) {
   assert(bufferLen > 0);
   HorizontalLayout resultLayout = HorizontalLayout::Builder();
-  UTF8Decoder decoder(buffer);
+  Ion::UTF8Decoder decoder(buffer);
   const char * currentPointer = buffer;
   CodePoint codePoint = decoder.nextCodePoint();
   const char * nextPointer = decoder.stringPosition();
diff --git a/poincare/src/parsing/tokenizer.cpp b/poincare/src/parsing/tokenizer.cpp
index 6c5b8c762..b45dffbd0 100644
--- a/poincare/src/parsing/tokenizer.cpp
+++ b/poincare/src/parsing/tokenizer.cpp
@@ -14,7 +14,7 @@ static inline bool isDigit(const CodePoint c) {
 }
 
 const CodePoint Tokenizer::nextCodePoint(PopTest popTest, CodePoint context, bool * testResult) {
-  UTF8Decoder decoder(m_text);
+  Ion::UTF8Decoder decoder(m_text);
   CodePoint c = decoder.nextCodePoint();
   const char * nextTextPosition = decoder.stringPosition();
   bool shouldPop = popTest(c, context);
@@ -68,7 +68,7 @@ Token Tokenizer::popNumber() {
   const char * fractionalPartText = m_text;
   size_t fractionalPartLength = 0;
 
-  assert(integralPartLength > 0 || UTF8Helper::CodePointIs(m_text, '.'));
+  assert(integralPartLength > 0 || Ion::UTF8Helper::CodePointIs(m_text, '.'));
   if (canPopCodePoint('.')) {
     fractionalPartText = m_text;
     fractionalPartLength = popDigits();
@@ -177,7 +177,7 @@ Token Tokenizer::popToken() {
     Token result(Token::Identifier);
     // TODO compute size manually?
     constexpr int squareRootCharLength = 3;
-    assert(UTF8Decoder::CharSizeOfCodePoint(UCodePointSquareRoot) == squareRootCharLength);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint(UCodePointSquareRoot) == squareRootCharLength);
     result.setString(start, squareRootCharLength);
     return result;
   }
diff --git a/poincare/src/print_float.cpp b/poincare/src/print_float.cpp
index 89a27c61b..266532169 100644
--- a/poincare/src/print_float.cpp
+++ b/poincare/src/print_float.cpp
@@ -26,26 +26,26 @@ void PrintFloat::printBase10IntegerWithDecimalMarker(char * buffer, int bufferLe
   constexpr int tempBufferSize = PrintFloat::k_maxFloatBufferLength;
   char tempBuffer[tempBufferSize];
   int intLength = i.serialize(tempBuffer, tempBufferSize);
-  int firstDigitChar = UTF8Helper::CodePointIs(tempBuffer, '-') ? 1 : 0;
-  /* We should use the UTF8Decoder to write code points in buffers, but it is
+  int firstDigitChar = Ion::UTF8Helper::CodePointIs(tempBuffer, '-') ? 1 : 0;
+  /* We should use the Ion::UTF8Decoder to write code points in buffers, but it is
    * much clearer to manipulate chars directly as we know that the code point we
    * use ('.', '0, '1', '2', ...) are only one char long. */
   for (int k = bufferLength-1; k >= firstDigitChar; k--) {
     if (k == decimalMarkerPosition) {
-      assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
       buffer[k] = '.';
       continue;
     }
     if (intLength > firstDigitChar) {
-      assert(UTF8Decoder::CharSizeOfCodePoint(tempBuffer[intLength-1]) == 1);
+      assert(Ion::UTF8Decoder::CharSizeOfCodePoint(tempBuffer[intLength-1]) == 1);
       buffer[k] = tempBuffer[--intLength];
       continue;
     }
-    assert(UTF8Decoder::CharSizeOfCodePoint('0') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('0') == 1);
     buffer[k] = '0';
   }
   if (firstDigitChar == 1) {
-    assert(UTF8Decoder::CharSizeOfCodePoint(tempBuffer[0]) == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint(tempBuffer[0]) == 1);
     buffer[0] = tempBuffer[0];
   }
 }
@@ -158,7 +158,7 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int bufferSize, in
   int numberOfZerosRemoved = 0;
   while (digit.isZero() && numberOfCharsForMantissaWithoutSign > minimumNumberOfCharsInMantissa &&
       (numberOfCharsForMantissaWithoutSign > exponentInBase10+1 || mode == Preferences::PrintFloatMode::Scientific)) {
-    assert(UTF8Decoder::CharSizeOfCodePoint('0') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('0') == 1);
     numberOfCharsForMantissaWithoutSign--;
     dividend = quotient;
     quotient = Integer::Division(dividend, Integer(10)).quotient;
@@ -174,14 +174,14 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int bufferSize, in
   // Force a decimal marker if there is fractional part
   bool decimalMarker = (mode == Preferences::PrintFloatMode::Scientific && numberOfCharsForMantissaWithoutSign > 1) || (mode == Preferences::PrintFloatMode::Decimal && numberOfCharsForMantissaWithoutSign > exponentInBase10 +1);
   if (decimalMarker) {
-    assert(UTF8Decoder::CharSizeOfCodePoint('.') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('.') == 1);
     numberOfCharsForMantissaWithoutSign++;
   }
 
   /* Find the position of the decimal marker position */
   int decimalMarkerPosition = exponentInBase10 < 0 || mode == Preferences::PrintFloatMode::Scientific ? 1 : exponentInBase10+1;
   decimalMarkerPosition = f < 0 ? decimalMarkerPosition+1 : decimalMarkerPosition;
-  assert(UTF8Decoder::CharSizeOfCodePoint('-') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint('-') == 1);
 
   /* Part III: Exponent */
 
@@ -189,12 +189,12 @@ int PrintFloat::convertFloatToTextPrivate(T f, char * buffer, int bufferSize, in
   if (exponentInBase10 < 0){
     // If the exponent is < 0, we need a additional char for the sign
     numberOfCharExponent++;
-    assert(UTF8Decoder::CharSizeOfCodePoint('-') == 1);
+    assert(Ion::UTF8Decoder::CharSizeOfCodePoint('-') == 1);
   }
 
   /* Part III: print mantissa*10^exponent */
   int numberOfCharsForMantissaWithSign = f >= 0 ? numberOfCharsForMantissaWithoutSign : numberOfCharsForMantissaWithoutSign + 1;
-  assert(UTF8Decoder::CharSizeOfCodePoint('-') == 1);
+  assert(Ion::UTF8Decoder::CharSizeOfCodePoint('-') == 1);
   // Print mantissa
   assert(!dividend.isOverflow());
   if (numberOfCharsForMantissaWithSign >= bufferSize) {
diff --git a/poincare/src/serialization_helper.cpp b/poincare/src/serialization_helper.cpp
index 7c9ec1fb9..9902ca63b 100644
--- a/poincare/src/serialization_helper.cpp
+++ b/poincare/src/serialization_helper.cpp
@@ -39,7 +39,7 @@ static int serializeChild(
   // Write the child with parentheses if needed
   bool addParentheses = parentNode->childNeedsParenthesis(childNode);
   if (addParentheses) {
-    numberOfChar += UTF8Decoder::CodePointToChars('(', buffer+numberOfChar, bufferSize - numberOfChar);
+    numberOfChar += Ion::UTF8Decoder::CodePointToChars('(', buffer+numberOfChar, bufferSize - numberOfChar);
     if (numberOfChar >= bufferSize-1) {
       return bufferSize-1;
     }
@@ -50,7 +50,7 @@ static int serializeChild(
     return bufferSize-1;
   }
   if (addParentheses) {
-    numberOfChar += UTF8Decoder::CodePointToChars(')', buffer+numberOfChar, bufferSize - numberOfChar);
+    numberOfChar += Ion::UTF8Decoder::CodePointToChars(')', buffer+numberOfChar, bufferSize - numberOfChar);
   }
   if (numberOfChar >= bufferSize-1) {
     assert(buffer[bufferSize - 1] == 0);
@@ -134,7 +134,7 @@ int SerializationHelper::Prefix(
   }
 
   // Add the opening parenthese
-  numberOfChar += UTF8Decoder::CodePointToChars('(', buffer+numberOfChar, bufferSize - numberOfChar);
+  numberOfChar += Ion::UTF8Decoder::CodePointToChars('(', buffer+numberOfChar, bufferSize - numberOfChar);
   if (numberOfChar >= bufferSize-1) {
     return bufferSize-1;
   }
@@ -155,7 +155,7 @@ int SerializationHelper::Prefix(
 
     // Write the remaining children, separated with commas
     for (int i = firstChildIndex + 1; i < childrenCount; i++) {
-      numberOfChar += UTF8Decoder::CodePointToChars(',', buffer+numberOfChar, bufferSize - numberOfChar);
+      numberOfChar += Ion::UTF8Decoder::CodePointToChars(',', buffer+numberOfChar, bufferSize - numberOfChar);
       if (numberOfChar >= bufferSize-1) {
         return bufferSize-1;
       }
@@ -168,7 +168,7 @@ int SerializationHelper::Prefix(
   }
 
   // Add the closing parenthese
-  numberOfChar += UTF8Decoder::CodePointToChars(')', buffer+numberOfChar, bufferSize - numberOfChar);
+  numberOfChar += Ion::UTF8Decoder::CodePointToChars(')', buffer+numberOfChar, bufferSize - numberOfChar);
   if (numberOfChar >= bufferSize-1) {
     return bufferSize-1;
   }
@@ -183,7 +183,7 @@ int SerializationHelper::CodePoint(char * buffer, int bufferSize, class CodePoin
       return result;
     }
   }
-  size_t size = UTF8Decoder::CodePointToChars(c, buffer, bufferSize);
+  size_t size = Ion::UTF8Decoder::CodePointToChars(c, buffer, bufferSize);
   if (size <= bufferSize - 1) {
     buffer[size] = 0;
   } else {
diff --git a/poincare/src/symbol.cpp b/poincare/src/symbol.cpp
index 65037ff94..83396a17d 100644
--- a/poincare/src/symbol.cpp
+++ b/poincare/src/symbol.cpp
@@ -151,7 +151,7 @@ Expression Symbol::UntypedBuilder(const char * name, size_t length, Context * co
 }
 
 bool SymbolNode::isUnknown(CodePoint unknownSymbol) const {
-  bool result = UTF8Helper::CodePointIs(m_name, unknownSymbol);
+  bool result = Ion::UTF8Helper::CodePointIs(m_name, unknownSymbol);
   if (result) {
     assert(m_name[1] == 0);
   }
@@ -161,7 +161,7 @@ bool SymbolNode::isUnknown(CodePoint unknownSymbol) const {
 Symbol Symbol::Builder(CodePoint name) {
   constexpr int bufferSize = CodePoint::MaxCodePointCharLength + 1;
   char buffer[bufferSize];
-  int codePointSize = UTF8Decoder::CodePointToChars(name, buffer, bufferSize);
+  int codePointSize = Ion::UTF8Decoder::CodePointToChars(name, buffer, bufferSize);
   assert(codePointSize <= bufferSize);
   return Symbol::Builder(buffer, codePointSize);
 }
diff --git a/poincare/src/symbol_abstract.cpp b/poincare/src/symbol_abstract.cpp
index 8ea0b00ed..b4b557d81 100644
--- a/poincare/src/symbol_abstract.cpp
+++ b/poincare/src/symbol_abstract.cpp
@@ -48,7 +48,7 @@ T SymbolAbstract::Builder(const char * name, int length) {
 }
 
 size_t SymbolAbstract::TruncateExtension(char * dst, const char * src, size_t len) {
-  return UTF8Helper::CopyUntilCodePoint(dst, len, src, '.');
+  return Ion::UTF8Helper::CopyUntilCodePoint(dst, len, src, '.');
 }
 
 bool SymbolAbstract::matches(const SymbolAbstract & symbol, ExpressionTest test, Context & context) {