diff --git a/src/Registration/Autoloader.php b/src/Registration/Autoloader.php
index 0039e9e..859db3d 100644
--- a/src/Registration/Autoloader.php
+++ b/src/Registration/Autoloader.php
@@ -1,39 +1,40 @@
 <?php
 declare(strict_types=1);
 
 namespace Keruald\OmniTools\Registration;
 
+use Keruald\OmniTools\Strings\Multibyte\StringUtilities;
+
 class Autoloader {
 
     ///
     /// PSR-4
     ///
 
     public static function registerPSR4 (string $namespace, string $path) : void {
         spl_autoload_register(function ($class) use ($namespace, $path) {
-            $len = strlen($namespace);
-
-            if (substr($class, 0, $len) === $namespace) {
+            if (StringUtilities::startsWith($class, $namespace)) {
+                $len = strlen($namespace);
                 $classPath = Autoloader::getPathFor(substr($class, $len));
                 include $path . '/' . $classPath;
             }
         });
     }
 
     public static function getPathFor (string $name) : string {
         return str_replace("\\", "/", $name) . '.php';
     }
 
     ///
     /// Methods to register OmniTools library
     ///
 
     public static function selfRegister () : void {
         self::registerPSR4("Keruald\\OmniTools\\", self::getLibraryPath());
     }
 
     public static function getLibraryPath () : string {
         return dirname(__DIR__);
     }
 
 }
diff --git a/src/Strings/Multibyte/OmniString.php b/src/Strings/Multibyte/OmniString.php
index ba70c7b..d4f7d3e 100644
--- a/src/Strings/Multibyte/OmniString.php
+++ b/src/Strings/Multibyte/OmniString.php
@@ -1,68 +1,76 @@
 <?php
 declare(strict_types=1);
 
 namespace Keruald\OmniTools\Strings\Multibyte;
 
 class OmniString {
 
     use WithEncoding;
 
     ///
     /// Private members
     ///
 
     /**
      * @var string
      */
     private $value;
 
     ///
     /// Constructor
     ///
 
     public function __construct (string $value = '', string $encoding = '') {
         $this->value = $value;
         $this->setEncoding($encoding ?: "UTF-8");
     }
 
     ///
     /// Magic methods
     ///
 
     public function __toString() : string {
         return $this->value;
     }
 
     ///
     /// Helper methods
     ///
 
     public function pad(
         int $padLength = 0,
         string $padString = ' ',
         int $padType = STR_PAD_RIGHT
     ) : string {
         return (new StringPad)
             ->setInput($this->value)
             ->setEncoding($this->encoding)
             ->setPadLength($padLength)
             ->setPadString($padString)
             ->setPadType($padType)
             ->pad();
     }
 
+    public function startsWith (string $start) : bool {
+        return StringUtilities::startsWith($this->value, $start);
+    }
+
+    public function endsWith (string $end) : bool {
+        return StringUtilities::endsWith($this->value, $end);
+    }
+
     /**
      * @return string
      */
     public function getValue () : string {
         return $this->value;
     }
 
     /**
      * @param string $value
      */
     public function setValue (string $value) {
         $this->value = $value;
     }
 
 }
diff --git a/src/Strings/Multibyte/StringUtilities.php b/src/Strings/Multibyte/StringUtilities.php
index e3491ac..15fd5cb 100644
--- a/src/Strings/Multibyte/StringUtilities.php
+++ b/src/Strings/Multibyte/StringUtilities.php
@@ -1,46 +1,56 @@
 <?php
 declare(strict_types=1);
 
 namespace Keruald\OmniTools\Strings\Multibyte;
 
 class StringUtilities {
 
     /**
      * Pads a multibyte string to a certain length with another string
      *
      * @param string $input the input string
      * @param int $padLength the target string size
      * @param string $padString the padding characters (optional, default is space)
      * @param int $padType STR_PAD_RIGHT, STR_PAD_LEFT, or STR_PAD_BOTH (optional, default is STR_PAD_RIGHT)
      * @param string $encoding the character encoding (optional)
      *
      * @return string the padded string
      *
      */
     public static function pad (
         string $input,
         int $padLength,
         string $padString = ' ',
         int $padType = STR_PAD_RIGHT,
         string $encoding = ''
     ) : string {
         return (new StringPad)
             ->setInput($input)
             ->setPadLength($padLength)
             ->setPadString($padString)
             ->setPadType($padType)
             ->setEncoding($encoding ?: mb_internal_encoding())
             ->pad();
     }
 
     public static function isSupportedEncoding (string $encoding) : bool {
         foreach (mb_list_encodings() as $supportedEncoding) {
             if ($encoding === $supportedEncoding) {
                 return true;
             }
         }
 
         return false;
     }
 
+    public static function startsWith (string $string, string $start) {
+        $length = mb_strlen($start);
+        return mb_substr($string, 0, $length) === $start;
+    }
+
+    public static function endsWith (string $string, string $end) {
+        $length = mb_strlen($end);
+        return $length === 0 || mb_substr($string, -$length) === $end;
+    }
+
 }
diff --git a/tests/Strings/Multibyte/OmniStringTest.php b/tests/Strings/Multibyte/OmniStringTest.php
index 6c85f8d..4e587f4 100644
--- a/tests/Strings/Multibyte/OmniStringTest.php
+++ b/tests/Strings/Multibyte/OmniStringTest.php
@@ -1,32 +1,50 @@
 <?php
 declare(strict_types=1);
 
 namespace Keruald\OmniTools\Tests\Strings\Multibyte;
 
 use Keruald\OmniTools\Strings\Multibyte\OmniString;
 use PHPUnit\Framework\TestCase;
 
 use InvalidArgumentException;
 
 class OmniStringTest extends TestCase {
 
     /**
      * @var OmniString
      */
     private $string;
 
     protected function setUp () {
         $this->string = new OmniString("foo");
     }
 
     public function testToString () : void {
         $this->assertEquals("foo", (string)$this->string);
         $this->assertEquals("foo", $this->string->__toString());
     }
 
     public function testPad () : void {
         $paddedString = $this->string->pad(9, '-=-', STR_PAD_BOTH);
         $this->assertEquals("-=-foo-=-", $paddedString);
     }
 
+    public function testStartsWith () : void {
+        $this->assertTrue($this->string->startsWith("fo"));
+        $this->assertTrue($this->string->startsWith(""));
+        $this->assertTrue($this->string->startsWith("foo"));
+
+        $this->assertFalse($this->string->startsWith("Fo"));
+        $this->assertFalse($this->string->startsWith("bar"));
+    }
+
+    public function testEndsWith () : void {
+        $this->assertTrue($this->string->endsWith("oo"));
+        $this->assertTrue($this->string->endsWith(""));
+        $this->assertTrue($this->string->endsWith("foo"));
+
+        $this->assertFalse($this->string->endsWith("oO"));
+        $this->assertFalse($this->string->endsWith("bar"));
+    }
+
 }
diff --git a/tests/Strings/Multibyte/StringUtilitiesTest.php b/tests/Strings/Multibyte/StringUtilitiesTest.php
index 3ba3d37..8b848e3 100644
--- a/tests/Strings/Multibyte/StringUtilitiesTest.php
+++ b/tests/Strings/Multibyte/StringUtilitiesTest.php
@@ -1,75 +1,92 @@
 <?php
 declare(strict_types=1);
 
 namespace Keruald\OmniTools\Tests\Strings\Multibyte;
 
 use Keruald\OmniTools\Strings\Multibyte\StringUtilities;
 use PHPUnit\Framework\TestCase;
 
 class StringUtilitiesTest extends TestCase {
 
     ///
     /// Tests
     ///
 
     /**
      * @dataProvider providePadding
      */
     public function testPad (
         string $expected,
         string $input, int $padLength, string $padString, int $padType
     ) : void {
         $paddedString = StringUtilities::pad(
             $input, $padLength, $padString, $padType, "UTF-8"
         );
 
         $this->assertEquals($expected, $paddedString);
     }
 
     public function testPadWithDefaultArguments () : void {
         $this->assertEquals("foo ", StringUtilities::pad("foo", 4));
         $this->assertEquals("foo_", StringUtilities::pad("foo", 4, '_'));
         $this->assertEquals("_foo", StringUtilities::pad("foo", 4, '_', STR_PAD_LEFT));
     }
 
     public function testSupportedEncoding () : void {
         $this->assertTrue(StringUtilities::isSupportedEncoding("UTF-8"));
         $this->assertFalse(StringUtilities::isSupportedEncoding("notexisting"));
     }
 
+    public function testStartsWith () : void {
+        $this->assertTrue(StringUtilities::startsWith("foo", "fo"));
+        $this->assertTrue(StringUtilities::startsWith("foo", ""));
+        $this->assertTrue(StringUtilities::startsWith("foo", "foo"));
+
+        $this->assertFalse(StringUtilities::startsWith("foo", "bar"));
+    }
+
+    public function testEndsWith () : void {
+        $this->assertTrue(StringUtilities::endsWith("foo", "oo"));
+        $this->assertTrue(StringUtilities::endsWith("foo", ""));
+        $this->assertTrue(StringUtilities::endsWith("foo", "foo"));
+
+        $this->assertFalse(StringUtilities::endsWith("foo", "oO"));
+        $this->assertFalse(StringUtilities::endsWith("foo", "bar"));
+    }
+
     ///
     /// Data providers
     ///
 
     public function providePadding () : iterable {
         // Tests from http://3v4l.org/UnXTF
         // http://web.archive.org/web/20150711100913/http://3v4l.org/UnXTF
 
         yield ['àèòàFOOàèòà', "FOO", 11, "àèò", STR_PAD_BOTH];
         yield ['àèòFOOàèòà', "FOO", 10, "àèò", STR_PAD_BOTH];
         yield ['àèòBAAZàèòà', "BAAZ", 11, "àèò", STR_PAD_BOTH];
         yield ['àèòBAAZàèò', "BAAZ", 10, "àèò", STR_PAD_BOTH];
         yield ['FOOBAR', "FOOBAR", 6, "àèò", STR_PAD_BOTH];
         yield ['FOOBAR', "FOOBAR", 1, "àèò", STR_PAD_BOTH];
         yield ['FOOBAR', "FOOBAR", 0, "àèò", STR_PAD_BOTH];
         yield ['FOOBAR', "FOOBAR", -10, "àèò", STR_PAD_BOTH];
 
         yield ['àèòàèòàèFOO', "FOO", 11, "àèò", STR_PAD_LEFT];
         yield ['àèòàèòàFOO', "FOO", 10, "àèò", STR_PAD_LEFT];
         yield ['àèòàèòàBAAZ', "BAAZ", 11, "àèò", STR_PAD_LEFT];
         yield ['àèòàèòBAAZ', "BAAZ", 10, "àèò", STR_PAD_LEFT];
         yield ['FOOBAR', "FOOBAR", 6, "àèò", STR_PAD_LEFT];
         yield ['FOOBAR', "FOOBAR", 1, "àèò", STR_PAD_LEFT];
         yield ['FOOBAR', "FOOBAR", 0, "àèò", STR_PAD_LEFT];
         yield ['FOOBAR', "FOOBAR", -10, "àèò", STR_PAD_LEFT];
 
         yield ['FOOàèòàèòàè', "FOO", 11, "àèò", STR_PAD_RIGHT];
         yield ['FOOàèòàèòà', "FOO", 10, "àèò", STR_PAD_RIGHT];
         yield ['BAAZàèòàèòà', "BAAZ", 11, "àèò", STR_PAD_RIGHT];
         yield ['BAAZàèòàèò', "BAAZ", 10, "àèò", STR_PAD_RIGHT];
         yield ['FOOBAR', "FOOBAR", 6, "àèò", STR_PAD_RIGHT];
         yield ['FOOBAR', "FOOBAR", 1, "àèò", STR_PAD_RIGHT];
         yield ['FOOBAR', "FOOBAR", 0, "àèò", STR_PAD_RIGHT];
         yield ['FOOBAR', "FOOBAR", -10, "àèò", STR_PAD_RIGHT];
     }
 }