diff --git a/docs/04-message-translation.md b/docs/04-message-translation.md
index a52b73601..c6775ffc0 100644
--- a/docs/04-message-translation.md
+++ b/docs/04-message-translation.md
@@ -1,17 +1,52 @@
 # Message translation
 
-You're also able to translate your message to another language with Validation.
-The only thing one must do is to define the param `translator` as a callable that
-will handle the translation overwriting the default factory:
+You're able to translate message templates with Validation.
 
 ```php
-Factory::setDefaultInstance(
-    (new Factory())->withTranslator('gettext')
-);
+use Respect\Validation\Message\Translator\GettextTranslator;
+use Respect\Validation\ValidatorDefaults;
+
+ValidatorDefaults::setTranslator(new GettextTranslator());
+```
+
+After that, if you call the methods `getMessage()`, `getMessages()`, or `getFullMessage()` from the `ValidationException`, the messages will be translated. The example above will work if you have `gettext` properly configured.
+
+For non-static usage, pass the translator directly to the `Validator` constructor:
+
+```php
+use Respect\Validation\Factory;
+use Respect\Validation\Message\StandardFormatter;
+use Respect\Validation\Message\Translator\GettextTranslator;
+use Respect\Validation\Validator;
+
+$translator = new GettextTranslator();
+
+$validator = new Validator(new Factory(), new StandardFormatter(), $translator);
 ```
 
-The example above uses `gettext()` but you can use any other callable value, like
-`[$translator, 'trans']` or `you_custom_function()`.
+## Supported translators
 
-After that, if you call `getMessage()`, `getMessages()`, or `getFullMessage()`,
-the message will be translated.
+- `ArrayTranslator`: Translates messages using an array of messages.
+- `GettextTranslator`: Translates messages using the `gettext` extension.
+
+## Custom translators
+
+You can implement custom translators by creating a class that implements the `Translator` interface. Here's an example using the `stichoza/google-translate-php` package:
+
+```php
+use Respect\Validation\Message\Translator;
+use Stichoza\GoogleTranslate\GoogleTranslate;
+
+final class MyTranslator implements Translator
+{
+    public function __construct(
+        private readonly GoogleTranslate $googleTranslate
+    ) {
+    }
+
+    public function translate(string $message): string
+    {
+        return $this->googleTranslate->translate($message);
+    }
+}
+```
diff --git a/library/Factory.php b/library/Factory.php
index 2628a8dbb..22c01de1c 100644
--- a/library/Factory.php
+++ b/library/Factory.php
@@ -13,10 +13,6 @@
 use ReflectionException;
 use Respect\Validation\Exceptions\ComponentException;
 use Respect\Validation\Exceptions\InvalidClassException;
-use Respect\Validation\Message\Parameter\Processor;
-use Respect\Validation\Message\Parameter\Raw;
-use Respect\Validation\Message\Parameter\Stringify;
-use Respect\Validation\Message\Parameter\Trans;
 use Respect\Validation\Transformers\Aliases;
 use Respect\Validation\Transformers\DeprecatedAge;
 use Respect\Validation\Transformers\DeprecatedAttribute;
@@ -42,22 +38,8 @@ final class Factory
      */
     private array $rulesNamespaces = ['Respect\\Validation\\Rules'];
 
-    /**
-     * @var callable
-     */
-    private $translator;
-
-    private Processor $processor;
-
-    private Transformer $transformer;
-
-    private static Factory $defaultInstance;
-
-    public function __construct()
-    {
-        $this->translator = static fn (string $message) => $message;
-        $this->processor = new Raw(new Trans($this->translator, new Stringify()));
-        $this->transformer = new DeprecatedAttribute(
+    public function __construct(
+        private readonly Transformer $transformer = new DeprecatedAttribute(
             new DeprecatedKey(
                 new DeprecatedKeyValue(
                     new DeprecatedMinAndMax(
@@ -67,16 +49,8 @@ public function __construct()
                     )
                 )
             )
-        );
-    }
-
-    public static function getDefaultInstance(): self
-    {
-        if (!isset(self::$defaultInstance)) {
-            self::$defaultInstance = new self();
-        }
-
-        return self::$defaultInstance;
+        )
+    ) {
     }
 
     public function withRuleNamespace(string $rulesNamespace): self
@@ -87,33 +61,6 @@ public function withRuleNamespace(string $rulesNamespace): self
         return $clone;
     }
 
-    public function withTranslator(callable $translator): self
-    {
-        $clone = clone $this;
-        $clone->translator = $translator;
-        $clone->processor = new Raw(new Trans($translator, new Stringify()));
-
-        return $clone;
-    }
-
-    public function withParameterProcessor(Processor $processor): self
-    {
-        $clone = clone $this;
-        $clone->processor = $processor;
-
-        return $clone;
-    }
-
-    public function getTranslator(): callable
-    {
-        return $this->translator;
-    }
-
-    public function getParameterProcessor(): Processor
-    {
-        return $this->processor;
-    }
-
     /**
      * @param mixed[] $arguments
      */
@@ -122,11 +69,6 @@ public function rule(string $ruleName, array $arguments = []): Validatable
         return $this->createRuleSpec($this->transformer->transform(new RuleSpec($ruleName, $arguments)));
     }
 
-    public static function setDefaultInstance(self $defaultInstance): void
-    {
-        self::$defaultInstance = $defaultInstance;
-    }
-
     private function createRuleSpec(RuleSpec $ruleSpec): Validatable
     {
         $rule = $this->createRule($ruleSpec->name, $ruleSpec->arguments);
diff --git a/library/Message/Formatter.php b/library/Message/Formatter.php
index 4d6af775d..33e93678b 100644
--- a/library/Message/Formatter.php
+++ b/library/Message/Formatter.php
@@ -16,17 +16,17 @@ interface Formatter
     /**
      * @param array<string, mixed> $templates
      */
-    public function main(Result $result, array $templates): string;
+    public function main(Result $result, array $templates, Translator $translator): string;
 
     /**
      * @param array<string, mixed> $templates
      */
-    public function full(Result $result, array $templates, int $depth = 0): string;
+    public function full(Result $result, array $templates, Translator $translator, int $depth = 0): string;
 
     /**
      * @param array<string, mixed> $templates
      *
      * @return array<string, mixed>
      */
-    public function array(Result $result, array $templates): array;
+    public function array(Result $result, array $templates, Translator $translator): array;
 }
diff --git a/library/Message/Parameter/Processor.php b/library/Message/Parameter/Processor.php
deleted file mode 100644
index 1eef366fd..000000000
--- a/library/Message/Parameter/Processor.php
+++ /dev/null
@@ -1,15 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-interface Processor
-{
-    public function process(string $name, mixed $value, ?string $modifier = null): string;
-}
diff --git a/library/Message/Parameter/Raw.php b/library/Message/Parameter/Raw.php
deleted file mode 100644
index e9a573e5c..000000000
--- a/library/Message/Parameter/Raw.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use function is_bool;
-use function is_scalar;
-
-final class Raw implements Processor
-{
-    public function __construct(
-        private readonly Processor $nextProcessor,
-    ) {
-    }
-
-    public function process(string $name, mixed $value, ?string $modifier = null): string
-    {
-        if ($modifier === 'raw' && is_scalar($value)) {
-            return is_bool($value) ? (string) (int) $value : (string) $value;
-        }
-
-        return $this->nextProcessor->process($name, $value, $modifier);
-    }
-}
diff --git a/library/Message/Parameter/Stringify.php b/library/Message/Parameter/Stringify.php
deleted file mode 100644
index 6b1e9f608..000000000
--- a/library/Message/Parameter/Stringify.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use function is_string;
-use function Respect\Stringifier\stringify;
-
-final class Stringify implements Processor
-{
-    public function process(string $name, mixed $value, ?string $modifier = null): string
-    {
-        if ($name === 'name' && is_string($value)) {
-            return $value;
-        }
-
-        return stringify($value);
-    }
-}
diff --git a/library/Message/Parameter/Trans.php b/library/Message/Parameter/Trans.php
deleted file mode 100644
index 8a485e9e4..000000000
--- a/library/Message/Parameter/Trans.php
+++ /dev/null
@@ -1,35 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use function call_user_func;
-use function is_string;
-
-final class Trans implements Processor
-{
-    /** @var callable */
-    private $translator;
-
-    public function __construct(
-        callable $translator,
-        private readonly Processor $nextProcessor,
-    ) {
-        $this->translator = $translator;
-    }
-
-    public function process(string $name, mixed $value, ?string $modifier = null): string
-    {
-        if ($modifier === 'trans' && is_string($value)) {
-            return call_user_func($this->translator, $value);
-        }
-
-        return $this->nextProcessor->process($name, $value, $modifier);
-    }
-}
diff --git a/library/Message/Renderer.php b/library/Message/Renderer.php
index 75ca5367c..78187dd3b 100644
--- a/library/Message/Renderer.php
+++ b/library/Message/Renderer.php
@@ -13,5 +13,5 @@
 
 interface Renderer
 {
-    public function render(Result $result, ?string $template = null): string;
+    public function render(Result $result, Translator $translator, ?string $template = null): string;
 }
diff --git a/library/Message/StandardFormatter.php b/library/Message/StandardFormatter.php
index 7c93a7bbc..41d7951e9 100644
--- a/library/Message/StandardFormatter.php
+++ b/library/Message/StandardFormatter.php
@@ -29,29 +29,29 @@
 final class StandardFormatter implements Formatter
 {
     public function __construct(
-        private readonly Renderer $renderer,
+        private readonly Renderer $renderer = new StandardRenderer(),
     ) {
     }
 
     /**
      * @param array<string, mixed> $templates
      */
-    public function main(Result $result, array $templates): string
+    public function main(Result $result, array $templates, Translator $translator): string
     {
         $selectedTemplates = $this->selectTemplates($result, $templates);
         if (!$this->isFinalTemplate($result, $selectedTemplates)) {
             foreach ($this->extractDeduplicatedChildren($result) as $child) {
-                return $this->main($child, $selectedTemplates);
+                return $this->main($child, $selectedTemplates, $translator);
             }
         }
 
-        return $this->renderer->render($this->getTemplated($result, $selectedTemplates));
+        return $this->renderer->render($this->getTemplated($result, $selectedTemplates), $translator);
     }
 
     /**
      * @param array<string, mixed> $templates
      */
-    public function full(Result $result, array $templates, int $depth = 0): string
+    public function full(Result $result, array $templates, Translator $translator, int $depth = 0): string
     {
         $selectedTemplates = $this->selectTemplates($result, $templates);
         $isFinalTemplate = $this->isFinalTemplate($result, $selectedTemplates);
@@ -62,14 +62,14 @@ public function full(Result $result, array $templates, int $depth = 0): string
             $rendered .= sprintf(
                 '%s- %s' . PHP_EOL,
                 $indentation,
-                $this->renderer->render($this->getTemplated($result, $selectedTemplates)),
+                $this->renderer->render($this->getTemplated($result, $selectedTemplates), $translator),
             );
             $depth++;
         }
 
         if (!$isFinalTemplate) {
             foreach ($this->extractDeduplicatedChildren($result) as $child) {
-                $rendered .= $this->full($child, $selectedTemplates, $depth);
+                $rendered .= $this->full($child, $selectedTemplates, $translator, $depth);
                 $rendered .= PHP_EOL;
             }
         }
@@ -82,17 +82,23 @@ public function full(Result $result, array $templates, int $depth = 0): string
      *
      * @return array<string, mixed>
      */
-    public function array(Result $result, array $templates): array
+    public function array(Result $result, array $templates, Translator $translator): array
     {
         $selectedTemplates = $this->selectTemplates($result, $templates);
         $deduplicatedChildren = $this->extractDeduplicatedChildren($result);
         if (count($deduplicatedChildren) === 0 || $this->isFinalTemplate($result, $selectedTemplates)) {
-            return [$result->id => $this->renderer->render($this->getTemplated($result, $selectedTemplates))];
+            return [
+                $result->id => $this->renderer->render($this->getTemplated($result, $selectedTemplates), $translator),
+            ];
         }
 
         $messages = [];
         foreach ($deduplicatedChildren as $child) {
-            $messages[$child->id] = $this->array($child, $this->selectTemplates($child, $selectedTemplates));
+            $messages[$child->id] = $this->array(
+                $child,
+                $this->selectTemplates($child, $selectedTemplates),
+                $translator
+            );
             if (count($messages[$child->id]) !== 1) {
                 continue;
             }
@@ -101,7 +107,9 @@ public function array(Result $result, array $templates): array
         }
 
         if (count($messages) > 1) {
-            $self = ['__root__' => $this->renderer->render($this->getTemplated($result, $selectedTemplates))];
+            $self = [
+                '__root__' => $this->renderer->render($this->getTemplated($result, $selectedTemplates), $translator),
+            ];
 
             return $self + $messages;
         }
diff --git a/library/Message/StandardRenderer.php b/library/Message/StandardRenderer.php
index ee71312bc..dbe9285ea 100644
--- a/library/Message/StandardRenderer.php
+++ b/library/Message/StandardRenderer.php
@@ -10,66 +10,55 @@
 namespace Respect\Validation\Message;
 
 use ReflectionClass;
-use Respect\Validation\Exceptions\ComponentException;
-use Respect\Validation\Message\Parameter\Processor;
+use Respect\Stringifier\Stringifier;
+use Respect\Stringifier\Stringifiers\CompositeStringifier;
 use Respect\Validation\Mode;
 use Respect\Validation\Result;
 use Respect\Validation\Validatable;
-use Throwable;
 
-use function call_user_func;
+use function is_bool;
+use function is_scalar;
+use function is_string;
 use function preg_replace_callback;
-use function sprintf;
+use function print_r;
 
 final class StandardRenderer implements Renderer
 {
     /** @var array<string, array<Template>> */
     private array $templates = [];
 
-    /** @var callable */
-    private $translator;
+    private readonly Stringifier $stringifier;
 
-    public function __construct(
-        callable $translator,
-        private readonly Processor $processor
-    ) {
-        $this->translator = $translator;
+    public function __construct(?Stringifier $stringifier = null)
+    {
+        $this->stringifier = $stringifier ?? CompositeStringifier::createDefault();
     }
 
-    public function render(Result $result, ?string $template = null): string
+    public function render(Result $result, Translator $translator, ?string $template = null): string
     {
         $parameters = $result->parameters;
-        $parameters['name'] ??= $result->name ?? $this->processor->process('input', $result->input);
+        $parameters['name'] ??= $result->name ?? $this->placeholder('input', $result->input, $translator);
         $parameters['input'] = $result->input;
 
         $rendered = (string) preg_replace_callback(
             '/{{(\w+)(\|([^}]+))?}}/',
-            function (array $matches) use ($parameters) {
+            function (array $matches) use ($parameters, $translator) {
                 if (!isset($parameters[$matches[1]])) {
                     return $matches[0];
                 }
 
-                return $this->processor->process($matches[1], $parameters[$matches[1]], $matches[3] ?? null);
+                return $this->placeholder($matches[1], $parameters[$matches[1]], $translator, $matches[3] ?? null);
             },
-            $this->translate($template ?? $this->getTemplateMessage($result))
+            $translator->translate($template ?? $this->getTemplateMessage($result))
         );
 
         if (!$result->hasCustomTemplate() && $result->nextSibling !== null) {
-            $rendered .= ' ' . $this->render($result->nextSibling);
+            $rendered .= ' ' . $this->render($result->nextSibling, $translator);
         }
 
         return $rendered;
     }
 
-    private function translate(string $message): string
-    {
-        try {
-            return call_user_func($this->translator, $message);
-        } catch (Throwable $throwable) {
-            throw new ComponentException(sprintf('Failed to translate "%s"', $message), 0, $throwable);
-        }
-    }
-
     /** @return array<Template> */
     private function extractTemplates(Validatable $rule): array
     {
@@ -83,6 +72,23 @@ private function extractTemplates(Validatable $rule): array
         return $this->templates[$rule::class] ?? [];
     }
 
+    private function placeholder(string $name, mixed $value, Translator $translator, ?string $modifier = null): string
+    {
+        if ($modifier === 'raw' && is_scalar($value)) {
+            return is_bool($value) ? (string) (int) $value : (string) $value;
+        }
+
+        if ($modifier === 'trans' && is_string($value)) {
+            return $translator->translate($value);
+        }
+
+        if ($name === 'name' && is_string($value)) {
+            return $value;
+        }
+
+        return $this->stringifier->stringify($value, 0) ?? print_r($value, true);
+    }
+
     private function getTemplateMessage(Result $result): string
     {
         if ($result->hasCustomTemplate()) {
diff --git a/library/Message/Translator.php b/library/Message/Translator.php
new file mode 100644
index 000000000..a92c98c12
--- /dev/null
+++ b/library/Message/Translator.php
@@ -0,0 +1,15 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Message;
+
+interface Translator
+{
+    public function translate(string $message): string;
+}
diff --git a/library/Message/Translator/ArrayTranslator.php b/library/Message/Translator/ArrayTranslator.php
new file mode 100644
index 000000000..3e895b408
--- /dev/null
+++ b/library/Message/Translator/ArrayTranslator.php
@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Message\Translator;
+
+use Respect\Validation\Message\Translator;
+
+use function is_string;
+
+final class ArrayTranslator implements Translator
+{
+    /** @param array<string, string> $messages */
+    public function __construct(
+        private readonly array $messages
+    ) {
+    }
+
+    public function translate(string $message): string
+    {
+        if (isset($this->messages[$message]) && is_string($this->messages[$message])) {
+            return $this->messages[$message];
+        }
+
+        return $message;
+    }
+}
diff --git a/library/Message/Translator/DummyTranslator.php b/library/Message/Translator/DummyTranslator.php
new file mode 100644
index 000000000..9456c1623
--- /dev/null
+++ b/library/Message/Translator/DummyTranslator.php
@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+namespace Respect\Validation\Message\Translator;
+
+use Respect\Validation\Message\Translator;
+
+final class DummyTranslator implements Translator
+{
+    public function translate(string $message): string
+    {
+        return $message;
+    }
+}
diff --git a/library/Message/Translator/GettextTranslator.php b/library/Message/Translator/GettextTranslator.php
new file mode 100644
index 000000000..0c8d5bf57
--- /dev/null
+++ b/library/Message/Translator/GettextTranslator.php
@@ -0,0 +1,31 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Message\Translator;
+
+use Respect\Validation\Exceptions\ComponentException;
+use Respect\Validation\Message\Translator;
+
+use function function_exists;
+use function gettext;
+
+final class GettextTranslator implements Translator
+{
+    public function __construct()
+    {
+        if (!function_exists('gettext')) {
+            throw new ComponentException('This translator requires the gettext extension');
+        }
+    }
+
+    public function translate(string $message): string
+    {
+        return gettext($message);
+    }
+}
diff --git a/library/Validator.php b/library/Validator.php
index 9b33bfb85..44910934a 100644
--- a/library/Validator.php
+++ b/library/Validator.php
@@ -12,8 +12,7 @@
 use Respect\Validation\Exceptions\ValidationException;
 use Respect\Validation\Helpers\CanBindEvaluateRule;
 use Respect\Validation\Message\Formatter;
-use Respect\Validation\Message\StandardFormatter;
-use Respect\Validation\Message\StandardRenderer;
+use Respect\Validation\Message\Translator;
 use Respect\Validation\Mixins\StaticValidator;
 use Respect\Validation\Rules\AllOf;
 use Throwable;
@@ -43,19 +42,16 @@ final class Validator implements Validatable
     public function __construct(
         private readonly Factory $factory,
         private readonly Formatter $formatter,
+        private readonly Translator $translator,
     ) {
     }
 
     public static function create(Validatable ...$rules): self
     {
         $validator = new self(
-            Factory::getDefaultInstance(),
-            new StandardFormatter(
-                new StandardRenderer(
-                    Factory::getDefaultInstance()->getTranslator(),
-                    Factory::getDefaultInstance()->getParameterProcessor(),
-                )
-            )
+            ValidatorDefaults::getFactory(),
+            ValidatorDefaults::getFormatter(),
+            ValidatorDefaults::getTranslator()
         );
         $validator->rules = $rules;
 
@@ -94,9 +90,9 @@ public function assert(mixed $input, array|string|Throwable|null $template = nul
         }
 
         throw new ValidationException(
-            $this->formatter->main($result, $templates),
-            $this->formatter->full($result, $templates),
-            $this->formatter->array($result, $templates),
+            $this->formatter->main($result, $templates, $this->translator),
+            $this->formatter->full($result, $templates, $this->translator),
+            $this->formatter->array($result, $templates, $this->translator),
         );
     }
 
diff --git a/library/ValidatorDefaults.php b/library/ValidatorDefaults.php
new file mode 100644
index 000000000..b85eee07e
--- /dev/null
+++ b/library/ValidatorDefaults.php
@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation;
+
+use Respect\Stringifier\Stringifiers\CompositeStringifier;
+use Respect\Validation\Message\Formatter;
+use Respect\Validation\Message\StandardFormatter;
+use Respect\Validation\Message\StandardRenderer;
+use Respect\Validation\Message\Translator;
+use Respect\Validation\Message\Translator\DummyTranslator;
+
+final class ValidatorDefaults
+{
+    private static ?Factory $factory = null;
+
+    private static ?Formatter $formatter = null;
+
+    private static ?Translator $translator = null;
+
+    public static function setFactory(Factory $factory): void
+    {
+        self::$factory = $factory;
+    }
+
+    public static function getFactory(): Factory
+    {
+        if (self::$factory === null) {
+            self::$factory = new Factory();
+        }
+
+        return self::$factory;
+    }
+
+    public static function setFormatter(Formatter $formatter): void
+    {
+        self::$formatter = $formatter;
+    }
+
+    public static function getFormatter(): Formatter
+    {
+        if (self::$formatter === null) {
+            self::$formatter = new StandardFormatter();
+        }
+
+        return self::$formatter;
+    }
+
+    public static function setTranslator(Translator $translator): void
+    {
+        self::$translator = $translator;
+    }
+
+    public static function getTranslator(): Translator
+    {
+        if (self::$translator === null) {
+            self::$translator = new DummyTranslator();
+        }
+
+        return self::$translator;
+    }
+}
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
index 5f0aef96e..1878a741d 100644
--- a/phpstan.neon.dist
+++ b/phpstan.neon.dist
@@ -29,6 +29,10 @@ parameters:
       path: tests/integration/transformers/deprecated_min.phpt
     - message: '/Call to an undefined static method Respect\\Validation\\Validator::type\(\)./'
       path: tests/integration/transformers/deprecated_type.phpt
+    - message: '/Method .+\\TestingStringifier::stringify\(\) never returns null so it can be removed from the return type./'
+      path: tests/library/Message/TestingStringifier.php
+    - message: '/Parameter #1 \$messages of class .+\\ArrayTranslator constructor expects array<string, string>, array<string, int> given./'
+      path: tests/unit/Message/Translator/ArrayTranslatorTest.php
   level: 8
   treatPhpDocTypesAsCertain: false
   paths:
diff --git a/tests/integration/translator-assert.phpt b/tests/integration/translator-assert.phpt
deleted file mode 100644
index a3ddcd886..000000000
--- a/tests/integration/translator-assert.phpt
+++ /dev/null
@@ -1,34 +0,0 @@
---FILE--
-<?php
-
-require 'vendor/autoload.php';
-
-use Respect\Validation\Factory;
-use Respect\Validation\Validator;
-
-Factory::setDefaultInstance(
-    (new Factory())
-        ->withTranslator(static function (string $message): string {
-            return [
-                'All of the required rules must pass for {{name}}'
-                    => 'Todas as regras requeridas devem passar para {{name}}',
-                'The length of'
-                    => 'O comprimento de',
-                '{{name}} must be of type string'
-                    => '{{name}} deve ser do tipo string',
-                '{{name}} must be between {{minValue}} and {{maxValue}}'
-                    => '{{name}} deve possuir de {{minValue}} a {{maxValue}} caracteres',
-                '{{name}} must be a valid telephone number for country {{countryName|trans}}'
-                    => '{{name}} deve ser um número de telefone válido para o país {{countryName|trans}}',
-                'United States' => 'Estados Unidos',
-            ][$message] ?? $message;
-        })
-);
-
-exceptionFullMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->phone('US')->assert(0));
-?>
---EXPECT--
-- Todas as regras requeridas devem passar para 0
-  - 0 deve ser do tipo string
-  - O comprimento de 0 deve possuir de 2 a 15 caracteres
-  - 0 deve ser um número de telefone válido para o país Estados Unidos
diff --git a/tests/integration/translator-check.phpt b/tests/integration/translator-check.phpt
deleted file mode 100644
index 04188da83..000000000
--- a/tests/integration/translator-check.phpt
+++ /dev/null
@@ -1,21 +0,0 @@
---FILE--
-<?php
-
-require 'vendor/autoload.php';
-
-use Respect\Validation\Factory;
-use Respect\Validation\Validator;
-
-Factory::setDefaultInstance(
-    (new Factory())
-        ->withTranslator(static function (string $message): string {
-            return [
-                '{{name}} must be of type string' => '{{name}} deve ser do tipo string',
-            ][$message] ?? $message;
-        })
-);
-
-exceptionMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->assert(0));
-?>
---EXPECT--
-0 deve ser do tipo string
diff --git a/tests/integration/translator.phpt b/tests/integration/translator.phpt
new file mode 100644
index 000000000..43acbbfa9
--- /dev/null
+++ b/tests/integration/translator.phpt
@@ -0,0 +1,26 @@
+--FILE--
+<?php
+
+require 'vendor/autoload.php';
+
+use Respect\Validation\Message\Translator\ArrayTranslator;
+use Respect\Validation\Validator;
+use Respect\Validation\ValidatorDefaults;
+
+ValidatorDefaults::setTranslator(new ArrayTranslator([
+    'All of the required rules must pass for {{name}}' => 'Todas as regras requeridas devem passar para {{name}}',
+    'The length of' => 'O comprimento de',
+    '{{name}} must be of type string' => '{{name}} deve ser do tipo string',
+    '{{name}} must be between {{minValue}} and {{maxValue}}' => '{{name}} deve possuir de {{minValue}} a {{maxValue}} caracteres',
+    '{{name}} must be a valid telephone number for country {{countryName|trans}}'
+        => '{{name}} deve ser um número de telefone válido para o país {{countryName|trans}}',
+    'United States' => 'Estados Unidos',
+]));
+
+exceptionFullMessage(static fn() => Validator::stringType()->lengthBetween(2, 15)->phone('US')->assert(0));
+?>
+--EXPECT--
+- Todas as regras requeridas devem passar para 0
+  - 0 deve ser do tipo string
+  - O comprimento de 0 deve possuir de 2 a 15 caracteres
+  - 0 deve ser um número de telefone válido para o país Estados Unidos
diff --git a/tests/library/Message/Parameter/TestingProcessor.php b/tests/library/Message/Parameter/TestingProcessor.php
deleted file mode 100644
index 95ada7be0..000000000
--- a/tests/library/Message/Parameter/TestingProcessor.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Test\Message\Parameter;
-
-use Respect\Validation\Message\Parameter\Processor;
-
-use function json_encode;
-use function sprintf;
-
-final class TestingProcessor implements Processor
-{
-    public function process(string $name, mixed $value, ?string $modifier = null): string
-    {
-        if ($modifier !== null) {
-            return sprintf('%s(<%s:%s>)', $modifier, $name, $modifier);
-        }
-
-        return sprintf('<%s:%s>', $name, json_encode($value));
-    }
-}
diff --git a/tests/library/Message/TestingMessageRenderer.php b/tests/library/Message/TestingMessageRenderer.php
index 4c9b4d3b0..4ea23ddd9 100644
--- a/tests/library/Message/TestingMessageRenderer.php
+++ b/tests/library/Message/TestingMessageRenderer.php
@@ -10,11 +10,12 @@
 namespace Respect\Validation\Test\Message;
 
 use Respect\Validation\Message\Renderer;
+use Respect\Validation\Message\Translator;
 use Respect\Validation\Result;
 
 final class TestingMessageRenderer implements Renderer
 {
-    public function render(Result $result, ?string $template = null): string
+    public function render(Result $result, Translator $translator, ?string $template = null): string
     {
         return $template ?? $result->template;
     }
diff --git a/tests/library/Message/TestingStringifier.php b/tests/library/Message/TestingStringifier.php
new file mode 100644
index 000000000..d605a3700
--- /dev/null
+++ b/tests/library/Message/TestingStringifier.php
@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Test\Message;
+
+use Respect\Stringifier\Stringifier;
+
+use function print_r;
+use function sprintf;
+
+final class TestingStringifier implements Stringifier
+{
+    public function stringify(mixed $raw, int $depth): ?string
+    {
+        return sprintf('<%s:%d>', print_r($raw, true), $depth);
+    }
+}
diff --git a/tests/unit/FactoryTest.php b/tests/unit/FactoryTest.php
index 17f06fb3c..7493effd3 100644
--- a/tests/unit/FactoryTest.php
+++ b/tests/unit/FactoryTest.php
@@ -91,24 +91,4 @@ public function shouldThrowsAnExceptionWhenRuleIsNotFound(): void
 
         $factory->rule('nonExistingRule');
     }
-
-    #[Test]
-    public function shouldAlwaysReturnTheSameDefaultInstance(): void
-    {
-        self::assertSame(Factory::getDefaultInstance(), Factory::getDefaultInstance());
-    }
-
-    #[Test]
-    public function shouldBeAbleToOverwriteDefaultInstance(): void
-    {
-        $factory = new Factory();
-
-        $defaultInstance = Factory::getDefaultInstance();
-
-        Factory::setDefaultInstance($factory);
-
-        self::assertSame($factory, Factory::getDefaultInstance());
-
-        Factory::setDefaultInstance($defaultInstance);
-    }
 }
diff --git a/tests/unit/Message/Parameter/RawTest.php b/tests/unit/Message/Parameter/RawTest.php
deleted file mode 100644
index 5df789699..000000000
--- a/tests/unit/Message/Parameter/RawTest.php
+++ /dev/null
@@ -1,65 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\DataProvider;
-use PHPUnit\Framework\Attributes\Test;
-use Respect\Validation\Test\Message\Parameter\TestingProcessor;
-use Respect\Validation\Test\TestCase;
-
-#[CoversClass(Raw::class)]
-final class RawTest extends TestCase
-{
-    public const DEFAULT_NAME = 'foo';
-
-    #[Test]
-    #[DataProvider('providerForScalarValues')]
-    public function itShouldReturnRawValueWhenModifierIsRawAndInputIsScalar(mixed $value): void
-    {
-        $raw = new Raw(new TestingProcessor());
-
-        self::assertEquals($value, $raw->process(self::DEFAULT_NAME, $value, 'raw'));
-    }
-
-    #[Test]
-    public function itShouldReturnRawZeroWhenModifierIsRawAndInputIsFalse(): void
-    {
-        $raw = new Raw(new TestingProcessor());
-
-        self::assertSame('0', $raw->process(self::DEFAULT_NAME, false, 'raw'));
-    }
-
-    #[Test]
-    #[DataProvider('providerForNonScalarValues')]
-    public function itShouldUseNextProcessorWhenModifierIsRawButInputIsNonScalar(mixed $value): void
-    {
-        $next = new TestingProcessor();
-        $raw = new Raw($next);
-
-        self::assertEquals(
-            $next->process(self::DEFAULT_NAME, $value, 'raw'),
-            $raw->process(self::DEFAULT_NAME, $value, 'raw')
-        );
-    }
-
-    #[Test]
-    #[DataProvider('providerForScalarValues')]
-    public function itShouldUseNextProcessorWhenModifierInputIsScalarButModifierIsNotRaw(mixed $value): void
-    {
-        $next = new TestingProcessor();
-        $raw = new Raw($next);
-
-        self::assertEquals(
-            $next->process(self::DEFAULT_NAME, $value, 'something'),
-            $raw->process(self::DEFAULT_NAME, $value, 'something')
-        );
-    }
-}
diff --git a/tests/unit/Message/Parameter/StringifyTest.php b/tests/unit/Message/Parameter/StringifyTest.php
deleted file mode 100644
index e8650d5e1..000000000
--- a/tests/unit/Message/Parameter/StringifyTest.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\DataProvider;
-use PHPUnit\Framework\Attributes\Test;
-use Respect\Validation\Test\TestCase;
-
-use function Respect\Stringifier\stringify;
-
-#[CoversClass(Stringify::class)]
-final class StringifyTest extends TestCase
-{
-    public const DEFAULT_NAME = 'not_name';
-
-    #[Test]
-    #[DataProvider('providerForStringTypes')]
-    public function itShouldNotStringifyValueWhenNameIsNameAndValueIsString(string $value): void
-    {
-        $stringify = new Stringify();
-
-        self::assertEquals($value, $stringify->process('name', $value));
-    }
-
-    #[Test]
-    #[DataProvider('providerForAnyValues')]
-    public function itShouldReturnStringifiedValue(mixed $value): void
-    {
-        $stringify = new Stringify();
-
-        self::assertEquals(stringify($value), $stringify->process(self::DEFAULT_NAME, $value, 'trans'));
-    }
-}
diff --git a/tests/unit/Message/Parameter/TransTest.php b/tests/unit/Message/Parameter/TransTest.php
deleted file mode 100644
index f33486270..000000000
--- a/tests/unit/Message/Parameter/TransTest.php
+++ /dev/null
@@ -1,61 +0,0 @@
-<?php
-
-/*
- * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
- * SPDX-License-Identifier: MIT
- */
-
-declare(strict_types=1);
-
-namespace Respect\Validation\Message\Parameter;
-
-use PHPUnit\Framework\Attributes\CoversClass;
-use PHPUnit\Framework\Attributes\DataProvider;
-use PHPUnit\Framework\Attributes\Test;
-use Respect\Validation\Test\Message\Parameter\TestingProcessor;
-use Respect\Validation\Test\TestCase;
-
-#[CoversClass(Trans::class)]
-final class TransTest extends TestCase
-{
-    public const DEFAULT_NAME = 'foo';
-
-    #[Test]
-    #[DataProvider('providerForStringTypes')]
-    public function itShouldReturnTranslatedValueWhenModifierIsTransAndInputIsString(string $value): void
-    {
-        $translation = 'translated';
-        $translator = static fn(string $original) => [$value => $translation][$original] ?? 'Failed to translate';
-
-        $trans = new Trans($translator, new TestingProcessor());
-
-        self::assertEquals($translation, $trans->process(self::DEFAULT_NAME, $value, 'trans'));
-    }
-
-    #[Test]
-    #[DataProvider('providerForNonStringTypes')]
-    public function itShouldUseNextProcessorWhenModifierIsTransButInputIsNotString(mixed $value): void
-    {
-        $next = new TestingProcessor();
-        $trans = new Trans(static fn($original) => $original, $next);
-
-        self::assertEquals(
-            $next->process(self::DEFAULT_NAME, $value, 'trans'),
-            $trans->process(self::DEFAULT_NAME, $value, 'trans')
-        );
-    }
-
-    #[Test]
-    #[DataProvider('providerForScalarValues')]
-    public function itShouldUseNextProcessorWhenModifierInputIsStringButModifierIsNotTrans(mixed $value): void
-    {
-        $next = new TestingProcessor();
-
-        $trans = new Trans(static fn($original) => $original, $next);
-
-        self::assertEquals(
-            $next->process(self::DEFAULT_NAME, $value, 'something'),
-            $trans->process(self::DEFAULT_NAME, $value, 'something')
-        );
-    }
-}
diff --git a/tests/unit/Message/StandardFormatterTest.php b/tests/unit/Message/StandardFormatterTest.php
index a4263f47b..b03269896 100644
--- a/tests/unit/Message/StandardFormatterTest.php
+++ b/tests/unit/Message/StandardFormatterTest.php
@@ -16,6 +16,7 @@
 use Respect\Validation\Message\StandardFormatter\ArrayProvider;
 use Respect\Validation\Message\StandardFormatter\FullProvider;
 use Respect\Validation\Message\StandardFormatter\MainProvider;
+use Respect\Validation\Message\Translator\DummyTranslator;
 use Respect\Validation\Result;
 use Respect\Validation\Test\Builders\ResultBuilder;
 use Respect\Validation\Test\Message\TestingMessageRenderer;
@@ -39,7 +40,7 @@ public function itShouldFormatMainMessage(Result $result, string $expected, arra
     {
         $renderer = new StandardFormatter(new TestingMessageRenderer());
 
-        self::assertSame($expected, $renderer->main($result, $templates));
+        self::assertSame($expected, $renderer->main($result, $templates, new DummyTranslator()));
     }
 
     #[Test]
@@ -53,7 +54,7 @@ public function itShouldThrowAnExceptionWhenTryingToFormatAsMainAndTemplateIsInv
         $this->expectException(ComponentException::class);
         $this->expectExceptionMessage(sprintf('Template for "foo" must be a string, %s given', stringify($template)));
 
-        $renderer->main($result, ['foo' => $template]);
+        $renderer->main($result, ['foo' => $template], new DummyTranslator());
     }
 
     /** @param array<string, mixed> $templates */
@@ -63,7 +64,7 @@ public function itShouldFormatFullMessage(Result $result, string $expected, arra
     {
         $renderer = new StandardFormatter(new TestingMessageRenderer());
 
-        self::assertSame($expected, $renderer->full($result, $templates));
+        self::assertSame($expected, $renderer->full($result, $templates, new DummyTranslator()));
     }
 
     #[Test]
@@ -77,7 +78,7 @@ public function itShouldThrowAnExceptionWhenTryingToFormatAsFullAndTemplateIsInv
         $this->expectException(ComponentException::class);
         $this->expectExceptionMessage(sprintf('Template for "foo" must be a string, %s given', stringify($template)));
 
-        $renderer->full($result, ['foo' => $template]);
+        $renderer->full($result, ['foo' => $template], new DummyTranslator());
     }
 
     /**
@@ -90,7 +91,7 @@ public function itShouldFormatArrayMessage(Result $result, array $expected, arra
     {
         $renderer = new StandardFormatter(new TestingMessageRenderer());
 
-        self::assertSame($expected, $renderer->array($result, $templates));
+        self::assertSame($expected, $renderer->array($result, $templates, new DummyTranslator()));
     }
 
     #[Test]
@@ -104,6 +105,6 @@ public function itShouldThrowAnExceptionWhenTryingToFormatAsArrayAndTemplateIsIn
         $this->expectException(ComponentException::class);
         $this->expectExceptionMessage(sprintf('Template for "foo" must be a string, %s given', stringify($template)));
 
-        $renderer->array($result, ['foo' => $template]);
+        $renderer->array($result, ['foo' => $template], new DummyTranslator());
     }
 }
diff --git a/tests/unit/Message/StandardRendererTest.php b/tests/unit/Message/StandardRendererTest.php
index 1f164f3a5..62b684fb7 100644
--- a/tests/unit/Message/StandardRendererTest.php
+++ b/tests/unit/Message/StandardRendererTest.php
@@ -9,13 +9,13 @@
 
 namespace Respect\Validation\Message;
 
-use Exception;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\Test;
-use Respect\Validation\Exceptions\ComponentException;
+use Respect\Validation\Message\Translator\ArrayTranslator;
+use Respect\Validation\Message\Translator\DummyTranslator;
 use Respect\Validation\Mode;
 use Respect\Validation\Test\Builders\ResultBuilder;
-use Respect\Validation\Test\Message\Parameter\TestingProcessor;
+use Respect\Validation\Test\Message\TestingStringifier;
 use Respect\Validation\Test\TestCase;
 
 use function sprintf;
@@ -26,100 +26,205 @@ final class StandardRendererTest extends TestCase
     #[Test]
     public function itShouldRenderResultWithCustomTemplate(): void
     {
-        $renderer = new StandardRenderer(static fn(string $value) => $value, new TestingProcessor());
+        $renderer = new StandardRenderer(new TestingStringifier());
 
         $result = (new ResultBuilder())->template('This is my template')->build();
 
-        self::assertSame($result->template, $renderer->render($result));
+        self::assertSame($result->template, $renderer->render($result, new DummyTranslator()));
     }
 
     #[Test]
     public function itShouldRenderResultOverwritingCustomTemplateWhenTemplateIsPassedAsAnArgument(): void
     {
-        $renderer = new StandardRenderer(static fn(string $value) => $value, new TestingProcessor());
+        $renderer = new StandardRenderer(new TestingStringifier());
 
         $template = 'This is my brand new template';
 
         $result = (new ResultBuilder())->template('This is my template')->build();
 
-        self::assertSame($template, $renderer->render($result, $template));
+        self::assertSame($template, $renderer->render($result, new DummyTranslator(), $template));
     }
 
     #[Test]
     public function itShouldRenderResultProcessingParametersInTheTemplate(): void
     {
-        $processor = new TestingProcessor();
+        $stringifier = new TestingStringifier();
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $renderer = new StandardRenderer($stringifier);
 
         $key = 'foo';
-        $value = 42;
+        $value = true;
 
         $result = (new ResultBuilder())
-            ->template('Will replace {{foo}}')
+            ->template(sprintf('Will replace {{%s}}', $key))
             ->parameters([$key => $value])
             ->build();
 
         self::assertSame(
-            'Will replace ' . $processor->process($key, $value),
-            $renderer->render($result)
+            'Will replace ' . $stringifier->stringify($value, 0),
+            $renderer->render($result, new DummyTranslator())
+        );
+    }
+
+    #[Test]
+    public function itShouldRenderResultProcessingRawParametersInTheTemplate(): void
+    {
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
+
+        $key = 'foo';
+        $value = 0.1;
+
+        $result = (new ResultBuilder())
+            ->template(sprintf('Will replace {{%1$s}} and {{%1$s|raw}}', $key))
+            ->parameters([$key => $value])
+            ->build();
+
+        self::assertSame(
+            sprintf('Will replace %s and 0.1', $stringifier->stringify($value, 0)),
+            $renderer->render($result, new DummyTranslator())
+        );
+    }
+
+    #[Test]
+    public function itShouldRenderResultProcessingRawBooleanParametersInTheTemplate(): void
+    {
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
+
+        $key = 'foo';
+        $value = false;
+
+        $result = (new ResultBuilder())
+            ->template(sprintf('Will replace {{%1$s}} and {{%1$s|raw}}', $key))
+            ->parameters([$key => $value])
+            ->build();
+
+        self::assertSame(
+            sprintf('Will replace %s and 0', $stringifier->stringify($value, 0)),
+            $renderer->render($result, new DummyTranslator())
+        );
+    }
+
+    #[Test]
+    public function itShouldRenderResultProcessingTranslatableParametersInTheTemplate(): void
+    {
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
+
+        $key = 'foo';
+        $value = 'original';
+        $translation = 'translated';
+
+        $result = (new ResultBuilder())
+            ->template(sprintf('Will replace {{%1$s}} and {{%1$s|trans}}', $key))
+            ->parameters([$key => $value])
+            ->build();
+
+        self::assertSame(
+            sprintf('Will replace %s and %s', $stringifier->stringify($value, 0), $translation),
+            $renderer->render($result, new ArrayTranslator([$value => $translation]))
+        );
+    }
+
+    #[Test]
+    public function itShouldRenderResultProcessingNameParameterWhenItIsInTheTemplateAndItIsString(): void
+    {
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
+
+        $value = 'original';
+
+        $result = (new ResultBuilder())
+            ->template('Will replace {{name}}')
+            ->parameters(['name' => $value])
+            ->build();
+
+        self::assertSame(
+            sprintf('Will replace %s', $value),
+            $renderer->render($result, new DummyTranslator())
+        );
+    }
+
+    #[Test]
+    public function itShouldRenderResultProcessingNameParameterWhenItIsInTheTemplateAndItIsNotString(): void
+    {
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
+
+        $value = true;
+
+        $result = (new ResultBuilder())
+            ->template('Will replace {{name}}')
+            ->parameters(['name' => $value])
+            ->build();
+
+        self::assertSame(
+            sprintf('Will replace %s', $stringifier->stringify($value, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultProcessingNameAsSomeParameterInTheTemplate(): void
     {
-        $processor = new TestingProcessor();
+        $renderer = new StandardRenderer(new TestingStringifier());
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $name = 'my name';
 
         $result = (new ResultBuilder())
             ->template('Will replace {{name}}')
-            ->name('my name')
+            ->name($name)
             ->build();
 
         self::assertSame(
-            'Will replace ' . $processor->process('name', $result->name),
-            $renderer->render($result)
+            'Will replace ' . $name,
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultProcessingInputAsNameWhenResultHasNoName(): void
     {
-        $processor = new TestingProcessor();
+        $stringifier = new TestingStringifier();
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $renderer = new StandardRenderer($stringifier);
+
+        $input = 42;
 
         $result = (new ResultBuilder())
             ->template('Will replace {{name}}')
-            ->input(42)
+            ->input($input)
             ->build();
 
         self::assertSame(
-            sprintf(
-                'Will replace %s',
-                $processor->process('name', $processor->process('input', $result->input))
-            ),
-            $renderer->render($result)
+            sprintf('Will replace %s', $stringifier->stringify($input, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultProcessingInputAsSomeParameterInTheTemplate(): void
     {
-        $processor = new TestingProcessor();
+        $stringifier = new TestingStringifier();
+
+        $renderer = new StandardRenderer($stringifier);
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $input = 42;
 
         $result = (new ResultBuilder())
             ->template('Will replace {{input}}')
-            ->input(42)
+            ->input($input)
             ->build();
 
         self::assertSame(
-            'Will replace ' . $processor->process('input', $result->input),
-            $renderer->render($result)
+            sprintf('Will replace %s', $stringifier->stringify($input, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
@@ -128,9 +233,9 @@ public function itShouldRenderResultNotOverwritingNameParameterWithRealName(): v
     {
         $parameterNameValue = 'fake name';
 
-        $processor = new TestingProcessor();
+        $stringifier = new TestingStringifier();
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $renderer = new StandardRenderer($stringifier);
 
         $result = (new ResultBuilder())
             ->template('Will replace {{name}}')
@@ -139,40 +244,42 @@ public function itShouldRenderResultNotOverwritingNameParameterWithRealName(): v
             ->build();
 
         self::assertSame(
-            'Will replace ' . $processor->process('name', $parameterNameValue),
-            $renderer->render($result)
+            sprintf('Will replace %s', $parameterNameValue),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultNotOverwritingInputParameterWithRealInput(): void
     {
-        $processor = new TestingProcessor();
+        $stringifier = new TestingStringifier();
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $renderer = new StandardRenderer($stringifier);
+
+        $input = 'real input';
 
         $result = (new ResultBuilder())
             ->template('Will replace {{input}}')
-            ->input('real input')
+            ->input($input)
             ->parameters(['input' => 'fake input'])
             ->build();
 
         self::assertSame(
-            'Will replace ' . $processor->process('input', 'real input'),
-            $renderer->render($result)
+            sprintf('Will replace %s', $stringifier->stringify($input, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultProcessingNonExistingParameters(): void
     {
-        $renderer = new StandardRenderer(static fn(string $value) => $value, new TestingProcessor());
+        $renderer = new StandardRenderer(new TestingStringifier());
 
         $result = (new ResultBuilder())
             ->template('Will not replace {{unknown}}')
             ->build();
 
-        self::assertSame('Will not replace {{unknown}}', $renderer->render($result));
+        self::assertSame('Will not replace {{unknown}}', $renderer->render($result, new DummyTranslator()));
     }
 
     #[Test]
@@ -181,86 +288,61 @@ public function itShouldRenderResultTranslatingTemplate(): void
         $template = 'This is my template with {{foo}}';
         $translations = [$template => 'This is my translated template with {{foo}}'];
 
-        $renderer = new StandardRenderer(
-            static fn(string $value) => $translations[$value],
-            new TestingProcessor()
-        );
+        $renderer = new StandardRenderer(new TestingStringifier());
+        $translator = new ArrayTranslator($translations);
 
         $result = (new ResultBuilder())
             ->template($template)
             ->build();
 
-        self::assertSame($translations[$template], $renderer->render($result));
-    }
-
-    #[Test]
-    public function itShouldThrowAnExceptionWhenTranslatorDoesNotWork(): void
-    {
-        $renderer = new StandardRenderer(
-            static fn(string $value) => throw new Exception(),
-            new TestingProcessor()
-        );
-
-        $result = (new ResultBuilder())->template('Template')->build();
-
-        $this->expectException(ComponentException::class);
-        $this->expectExceptionMessage(sprintf('Failed to translate "%s"', $result->template));
-
-        $renderer->render($result);
+        self::assertSame($translations[$template], $renderer->render($result, $translator));
     }
 
     #[Test]
-    public function itShouldRenderResultWithTemplateAttachedToRule(): void
+    public function itShouldRenderResultWithNonCustomTemplate(): void
     {
-        $processor = new TestingProcessor();
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $stringifier = new TestingStringifier();
+        $renderer = new StandardRenderer($stringifier);
 
         $result = (new ResultBuilder())->build();
 
         self::assertSame(
-            sprintf(
-                '%s must be a valid stub',
-                $processor->process('name', $processor->process('input', $result->input))
-            ),
-            $renderer->render($result)
+            sprintf('%s must be a valid stub', $stringifier->stringify($result->input, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
-    public function itShouldRenderResultWithTemplateAttachedToRuleWithInvertedMode(): void
+    public function itShouldRenderResultWithNonCustomTemplateAndInvertedMode(): void
     {
-        $processor = new TestingProcessor();
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $stringifier = new TestingStringifier();
+        $renderer = new StandardRenderer($stringifier);
 
         $result = (new ResultBuilder())->mode(Mode::INVERTED)->build();
 
         self::assertSame(
-            sprintf(
-                '%s must not be a valid stub',
-                $processor->process('name', $processor->process('input', $result->input))
-            ),
-            $renderer->render($result)
+            sprintf('%s must not be a valid stub', $stringifier->stringify($result->input, 0)),
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultWithNonCustomTemplateWhenCannotFindAttachedTemplate(): void
     {
-        $processor = new TestingProcessor();
-        $renderer = new StandardRenderer(static fn(string $value) => $value, $processor);
+        $renderer = new StandardRenderer(new TestingStringifier());
 
         $result = (new ResultBuilder())->template('__not_standard__')->mode(Mode::INVERTED)->build();
 
         self::assertSame(
             $result->template,
-            $renderer->render($result)
+            $renderer->render($result, new DummyTranslator())
         );
     }
 
     #[Test]
     public function itShouldRenderResultWithItsSiblingsWhenItHasNoCustomTemplate(): void
     {
-        $renderer = new StandardRenderer(static fn(string $value) => $value, new TestingProcessor());
+        $renderer = new StandardRenderer(new TestingStringifier());
 
         $result = (new ResultBuilder())->template('__1st__')
             ->nextSibling(
@@ -274,7 +356,7 @@ public function itShouldRenderResultWithItsSiblingsWhenItHasNoCustomTemplate():
 
         $expect = '__1st__ __2nd__ __3rd__';
 
-        self::assertSame($expect, $renderer->render($result));
+        self::assertSame($expect, $renderer->render($result, new DummyTranslator()));
     }
 
     #[Test]
@@ -286,8 +368,8 @@ public function itShouldRenderResultWithoutItsSiblingsWhenItHasCustomTemplate():
             ->nextSibling((new ResultBuilder())->template('and this is a sibling')->build())
             ->build();
 
-        $renderer = new StandardRenderer(static fn(string $value) => $value, new TestingProcessor());
+        $renderer = new StandardRenderer(new TestingStringifier());
 
-        self::assertSame($template, $renderer->render($result));
+        self::assertSame($template, $renderer->render($result, new DummyTranslator()));
     }
 }
diff --git a/tests/unit/Message/Translator/ArrayTranslatorTest.php b/tests/unit/Message/Translator/ArrayTranslatorTest.php
new file mode 100644
index 000000000..ab64eeac1
--- /dev/null
+++ b/tests/unit/Message/Translator/ArrayTranslatorTest.php
@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * Copyright (c) Alexandre Gomes Gaigalas <alganet@gmail.com>
+ * SPDX-License-Identifier: MIT
+ */
+
+declare(strict_types=1);
+
+namespace Respect\Validation\Message\Translator;
+
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\Test;
+use Respect\Validation\Test\TestCase;
+
+#[CoversClass(ArrayTranslator::class)]
+final class ArrayTranslatorTest extends TestCase
+{
+    #[Test]
+    public function shouldReturnOriginalMessageWhenCannotFindTranslation(): void
+    {
+        $translator = new ArrayTranslator([]);
+        $message = 'This is a test message';
+
+        self::assertSame($message, $translator->translate($message));
+    }
+
+    #[Test]
+    public function shouldReturnTranslatedMessage(): void
+    {
+        $messages = ['foo' => 'bar'];
+
+        $translator = new ArrayTranslator($messages);
+
+        self::assertSame($messages['foo'], $translator->translate('foo'));
+    }
+
+    #[Test]
+    public function shouldReturnOriginalMessageWhenTranslationIsNotString(): void
+    {
+        $messages = ['foo' => 123];
+
+        $translator = new ArrayTranslator($messages);
+
+        self::assertSame('foo', $translator->translate('foo'));
+    }
+}