diff --git a/src/BootstrapRenderer.php b/src/BootstrapRenderer.php
index 9dd6253..13e1157 100644
--- a/src/BootstrapRenderer.php
+++ b/src/BootstrapRenderer.php
@@ -14,6 +14,7 @@
 use Nette\Forms\Form;
 use Nette\Forms\FormRenderer;
 use Nette\Utils\Html;
+use SplObjectStorage;
 
 /**
  * Converts a Form into Bootstrap 4 HTML output.
@@ -41,7 +42,12 @@ class BootstrapRenderer implements FormRenderer
 	 */
 	protected $gridBreakPoint = 'sm';
 
-	/** @var BootstrapForm */
+	/**
+	 * Not necessarily a BootstrapForm: Nette\Forms\Blueprint (the {formPrint} macro) renders
+	 * a plain dummy form through a clone of this renderer.
+	 *
+	 * @var Form
+	 */
 	protected $form;
 
 	/** @var int */
@@ -56,16 +62,28 @@ class BootstrapRenderer implements FormRenderer
 	/** @var bool */
 	private $groupHidden = true;
 
+	/**
+	 * What this renderer has already drawn in the current render.
+	 *
+	 * Tracked by identity rather than only through RendererOptions::_RENDERED, because the
+	 * dummy controls Nette\Forms\Blueprint feeds us forward getOption() to the control they
+	 * wrap, so an option written here would be read back off a different object.
+	 *
+	 * @var SplObjectStorage<BaseControl|BootstrapRow, null>
+	 */
+	private $renderedControls;
+
 	public function __construct(int $mode = RenderMode::VERTICAL_MODE)
 	{
 		$this->setMode($mode);
+		$this->renderedControls = new SplObjectStorage();
 	}
 
 	/**
 	 * Sets the form for which to render. Used only if a specific function of the renderer must be executed
 	 * outside of render(), such as during assisted manual rendering.
 	 */
-	public function attachForm(BootstrapForm $form): void
+	public function attachForm(Form $form): void
 	{
 		$this->form = $form;
 	}
@@ -306,8 +324,6 @@ public function setGroupHidden(bool $groupHidden): BootstrapRenderer
 
 	/**
 	 * Provides complete form rendering.
-	 *
-	 * @param BootstrapForm $form
 	 */
 	public function render(Form $form): string
 	{
@@ -327,6 +343,8 @@ public function render(Form $form): string
 	 */
 	public function renderBegin(): string
 	{
+		$this->renderedControls = new SplObjectStorage();
+
 		foreach ($this->form->getControls() as $control) {
 			if ($control instanceof BaseControl || $control instanceof BootstrapRow) {
 				$control->setOption(RendererOptions::_RENDERED, false);
@@ -436,10 +454,16 @@ public function renderBody(): string
 	 */
 	public function renderControl(BaseControl $control): string
 	{
-		/** @var Html $controlHtml */
 		$controlHtml = $control->getControl();
-		$control->setOption(RendererOptions::_RENDERED, true);
-		if (($this->form->showValidation || $control->hasErrors()) && $control instanceof IValidationInput) {
+		$this->markRendered($control);
+
+		// Blueprint's dummy controls return a bare '{input ...}' placeholder, which has
+		// no attributes to configure — pass it through untouched
+		if (!$controlHtml instanceof Html) {
+			return (string) $controlHtml;
+		}
+
+		if (($this->shouldShowValidation() || $control->hasErrors()) && $control instanceof IValidationInput) {
 			$controlHtml = $control->showValidation($controlHtml);
 		}
 
@@ -468,7 +492,7 @@ public function renderControls($parent): string
 				continue;
 			}
 
-			if ($control->getOption(RendererOptions::_RENDERED)) {
+			if ($this->isRendered($control)) {
 				continue;
 			}
 
@@ -509,12 +533,18 @@ public function renderEnd(): string
 	 */
 	public function renderLabel(BaseControl $control): Html
 	{
+		$controlLabel = $control->getLabel();
+
+		// Blueprint's dummy controls carry no caption but do return a '{label ...}' placeholder,
+		// which already expands to a whole <label> — emit it raw instead of nesting it in ours
+		if (is_string($controlLabel) && $controlLabel !== '') {
+			return Html::el()->setHtml($controlLabel);
+		}
+
 		if ($control->getCaption() === null) {
 			return Html::el();
 		}
 
-		$controlLabel = $control->getLabel();
-
 		if ($controlLabel instanceof Html && $controlLabel->getName() === 'label') {
 			// the control has already provided us with the element, no need to create our own
 			$controlLabel = $this->configElem(Cnf::LABEL, $controlLabel);
@@ -604,6 +634,40 @@ public function setMode(int $renderMode): void
 		$this->renderMode = $renderMode;
 	}
 
+	/**
+	 * Records that this renderer has drawn the control, both for itself and, as before,
+	 * as an option other code may read.
+	 *
+	 * @param BaseControl|BootstrapRow $control
+	 */
+	protected function markRendered($control): void
+	{
+		$this->renderedControls->attach($control);
+		$control->setOption(RendererOptions::_RENDERED, true);
+	}
+
+	/**
+	 * Whether the control should be skipped: either this renderer has already drawn it,
+	 * or somebody marked it as rendered by hand.
+	 *
+	 * @param BaseControl|BootstrapRow $control
+	 */
+	protected function isRendered($control): bool
+	{
+		return $this->renderedControls->contains($control)
+			|| (bool) $control->getOption(RendererOptions::_RENDERED);
+	}
+
+	/**
+	 * Whether valid controls should be explicitly marked as valid.
+	 *
+	 * Only a BootstrapForm knows about this, and the attached form is not always one.
+	 */
+	protected function shouldShowValidation(): bool
+	{
+		return $this->form instanceof BootstrapForm && $this->form->isShowValidation();
+	}
+
 	/**
 	 * Fetch config tailored for current render mode
 	 *
@@ -680,7 +744,7 @@ protected function renderFeedback(?BaseControl $control = null): ?Html
 				$isValid = false;
 				$showFeedback = true;
 				$messages = $control->getErrors();
-			} elseif ($this->form->showValidation) {
+			} elseif ($this->shouldShowValidation()) {
 				$isValid = true;
 				// control is valid and we want to explicitly show that it's valid
 				$message = $control->getOption(RendererOptions::FEEDBACK_VALID);
@@ -747,4 +811,13 @@ protected function renderFeedback(?BaseControl $control = null): ?Html
 		}
 	}
 
+	/**
+	 * Blueprint renders through a clone of the form's renderer; it must not inherit
+	 * bookkeeping from the render the original may be in the middle of.
+	 */
+	public function __clone()
+	{
+		$this->renderedControls = new SplObjectStorage();
+	}
+
 }
diff --git a/src/Enums/RendererOptions.php b/src/Enums/RendererOptions.php
index 9eee5bf..85795c0 100644
--- a/src/Enums/RendererOptions.php
+++ b/src/Enums/RendererOptions.php
@@ -11,6 +11,10 @@ class RendererOptions
 
 	/**
 	 * Internal. If control has already been rendered.
+	 *
+	 * Deliberately NOT Nette's own 'rendered' key, which BaseControl::getControl() sets on
+	 * every fetch: the renderer must be able to tell "I drew this" apart from "somebody
+	 * asked for the html", or assisted manual rendering silently skips controls.
 	 */
 	public const _RENDERED = '_rendered';
 
diff --git a/src/Grid/BootstrapRow.php b/src/Grid/BootstrapRow.php
index 1c5c065..80218cb 100644
--- a/src/Grid/BootstrapRow.php
+++ b/src/Grid/BootstrapRow.php
@@ -201,7 +201,7 @@ public function setParent(?IContainer $parent = null, ?string $name = null): sta
 	 */
 	public function getOption(string $option)
 	{
-		return $this->options[$option];
+		return $this->options[$option] ?? null;
 	}
 
 	/**
diff --git a/src/Traits/FakeControlTrait.php b/src/Traits/FakeControlTrait.php
index 44b4466..f8965c0 100644
--- a/src/Traits/FakeControlTrait.php
+++ b/src/Traits/FakeControlTrait.php
@@ -2,8 +2,11 @@
 
 namespace Contributte\FormsBootstrap\Traits;
 
+use Nette\ComponentModel\Component;
+use Nette\ComponentModel\IComponent;
 use Nette\Forms\Control;
 use Nette\NotImplementedException;
+use Stringable;
 
 /**
  * Trait FakeControlTrait.
@@ -45,6 +48,45 @@ public function isOmitted(): bool
 		return true;
 	}
 
+	/**
+	 * Hierarchical name of the component, the way a real Nette component would report it.
+	 *
+	 * Needed because tools that walk $form->getControls() -- Nette\Forms\Blueprint, i.e. the
+	 * {formPrint} macro -- call this on everything they find, and a fake control is found too.
+	 *
+	 * @param class-string<IComponent>|null $type
+	 */
+	public function lookupPath(?string $type = null, bool $throw = true): ?string
+	{
+		$parent = $this->getParent();
+
+		// the searched-for ancestor is our direct parent, so the path is just our own name
+		if ($type !== null && $parent instanceof $type) {
+			return $this->getName();
+		}
+
+		$parentPath = $parent instanceof Component ? $parent->lookupPath($type, $throw) : null;
+
+		return ($parentPath === null || $parentPath === '' ? '' : $parentPath . IComponent::NameSeparator)
+			. $this->getName();
+	}
+
+	/**
+	 * A fake control has no label.
+	 *
+	 * @param string|Stringable|null $caption
+	 * @return null
+	 */
+	public function getLabel($caption = null)
+	{
+		return null;
+	}
+
+	public function isRequired(): bool
+	{
+		return false;
+	}
+
 	/**
 	 * Not supported
 	 *
diff --git a/tests/Grid/BootstrapRowTest.php b/tests/Grid/BootstrapRowTest.php
index cfce79c..5fcf555 100644
--- a/tests/Grid/BootstrapRowTest.php
+++ b/tests/Grid/BootstrapRowTest.php
@@ -2,10 +2,12 @@
 
 namespace Tests\Grid;
 
+use ArrayObject;
 use Contributte\FormsBootstrap\BootstrapForm;
 use Contributte\FormsBootstrap\Grid\BootstrapCell;
 use Contributte\FormsBootstrap\Grid\BootstrapRow;
 use Nette\Application\UI\Presenter;
+use Nette\Forms\Form;
 use Nette\NotImplementedException;
 use Tests\BaseTestCase;
 
@@ -113,6 +115,71 @@ public function testControlsAddedThroughCellStayReachableOnForm(): void
 		$this->assertSame('name', $this->form['name']->getName());
 	}
 
+	public function testRowHasNoLabelAndIsNeverRequired(): void
+	{
+		$this->assertNull($this->row->getLabel());
+		$this->assertNull($this->row->getLabel('caption'));
+		$this->assertFalse($this->row->isRequired());
+	}
+
+	public function testOptionsRoundTrip(): void
+	{
+		$this->row->setOption('description', 'Hello');
+
+		$this->assertSame('Hello', $this->row->getOption('description'));
+	}
+
+	public function testUnsetOptionIsNullAndDoesNotWarn(): void
+	{
+		$warnings = new ArrayObject();
+		set_error_handler(
+			static function (int $severity, string $message) use ($warnings): bool {
+				$warnings[] = $message;
+
+				return true;
+			},
+			E_WARNING,
+		);
+
+		try {
+			$value = $this->row->getOption('never-set');
+		} finally {
+			restore_error_handler();
+		}
+
+		$this->assertNull($value);
+		$this->assertSame([], $warnings->getArrayCopy());
+	}
+
+	public function testLookupPathOfRowDirectlyOnForm(): void
+	{
+		$this->assertSame($this->row->getName(), $this->row->lookupPath(Form::class));
+	}
+
+	public function testLookupPathOfRowInsideContainer(): void
+	{
+		$container = $this->form->addContainer('sub');
+		$nested = $container->addRow();
+
+		$this->assertSame('sub-' . $nested->getName(), $nested->lookupPath(Form::class));
+	}
+
+	/**
+	 * The fake control must report its path exactly like a real sibling would,
+	 * whatever the form happens to be attached to.
+	 */
+	public function testLookupPathMatchesRealControlInSamePlace(): void
+	{
+		$container = $this->form->addContainer('sub');
+		$nested = $container->addRow();
+		$real = $container->addText('x');
+
+		$expected = static fn (string $path): string => substr($path, 0, -strlen('x')) . $nested->getName();
+
+		$this->assertSame($expected($real->lookupPath(Form::class)), $nested->lookupPath(Form::class));
+		$this->assertSame($expected((string) $real->lookupPath()), $nested->lookupPath());
+	}
+
 	protected function setUp(): void
 	{
 		$this->form = new BootstrapForm();
diff --git a/tests/Rendering/BlueprintTest.php b/tests/Rendering/BlueprintTest.php
new file mode 100644
index 0000000..8640f0e
--- /dev/null
+++ b/tests/Rendering/BlueprintTest.php
@@ -0,0 +1,172 @@
+<?php declare (strict_types = 1);
+
+namespace Tests\Rendering;
+
+use Contributte\FormsBootstrap\BootstrapForm;
+use Contributte\FormsBootstrap\BootstrapRenderer;
+use Contributte\FormsBootstrap\Enums\BootstrapVersion;
+use Contributte\FormsBootstrap\Enums\RenderMode;
+use Nette\Forms\Blueprint;
+use Nette\Forms\Form;
+use Tests\BaseTestCase;
+
+/**
+ * Nette\Forms\Blueprint is what the {formPrint} Latte macro runs on. It renders a dummy
+ * plain Nette form through a clone of the form's own renderer.
+ *
+ * @see https://github.com/contributte/forms-bootstrap/issues/63
+ */
+class BlueprintTest extends BaseTestCase
+{
+
+	public function testGeneratesLatteForPlainForm(): void
+	{
+		$form = new BootstrapForm();
+		$form->addText('name', 'Name');
+		$form->addSubmit('send', 'Send');
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		$this->assertStringContainsString('{label name/}', $latte);
+		$this->assertStringContainsString('{input name}', $latte);
+		$this->assertStringContainsString('{input send}', $latte);
+		$this->assertStringContainsString('{inputError name}', $latte);
+	}
+
+	public function testKeepsBootstrapMarkupAroundPlaceholders(): void
+	{
+		$form = new BootstrapForm();
+		$form->setRenderMode(RenderMode::SIDE_BY_SIDE_MODE);
+		$form->addText('name', 'Name');
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		// the point of a bootstrap blueprint: the wrappers are the ones this renderer emits
+		$this->assertStringContainsString('class="form-group row"', $latte);
+		$this->assertStringContainsString('class="col-sm-9"', $latte);
+	}
+
+	public function testLabelPlaceholderIsNotNestedInAnotherLabel(): void
+	{
+		$form = new BootstrapForm();
+		$form->addText('name', 'Name');
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		// {label name/} expands to a whole <label>, so it must not sit inside one
+		$this->assertStringNotContainsString('<label', $latte);
+	}
+
+	public function testGroupedControlsAreRenderedOnce(): void
+	{
+		$form = new BootstrapForm();
+		$form->addGroup('Personal');
+		$form->addText('name', 'Name');
+		$form->addGroup('Other');
+		$form->addSelect('color', 'Color', ['r' => 'Red']);
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		$this->assertSame(1, substr_count($latte, '{input name}'));
+		$this->assertSame(1, substr_count($latte, '{input color}'));
+		$this->assertStringContainsString('<legend>Personal</legend>', $latte);
+		$this->assertStringContainsString('<legend>Other</legend>', $latte);
+	}
+
+	public function testHandlesContainersAndHiddenFields(): void
+	{
+		$form = new BootstrapForm();
+		$form->addHidden('token', 'x');
+		$form->addContainer('sub')->addText('nested', 'Nested');
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		$this->assertStringContainsString('{input sub-nested}', $latte);
+		$this->assertStringContainsString('{input token}', $latte);
+	}
+
+	/**
+	 * A BootstrapRow is a fake control, but Blueprint still walks it like any other.
+	 */
+	public function testHandlesGridRowsWithoutFailing(): void
+	{
+		$form = new BootstrapForm();
+		$row = $form->addRow();
+		$row->addCell(6)->addText('first', 'First');
+		$row->addCell(6)->addText('last', 'Last');
+
+		$latte = (new Blueprint())->generateLatte($form);
+
+		$this->assertStringContainsString('{input first}', $latte);
+		$this->assertStringContainsString('{input last}', $latte);
+	}
+
+	public function testBootstrap5Blueprint(): void
+	{
+		BootstrapForm::switchBootstrapVersion(BootstrapVersion::V5);
+
+		try {
+			$form = new BootstrapForm();
+			$form->setRenderMode(RenderMode::SIDE_BY_SIDE_MODE);
+			$form->addText('name', 'Name');
+
+			$latte = (new Blueprint())->generateLatte($form);
+
+			$this->assertStringContainsString('{input name}', $latte);
+			// the v5 wrapper, not v4's form-group/form-row
+			$this->assertStringContainsString('class="mb-3 row"', $latte);
+			$this->assertStringNotContainsString('form-group', $latte);
+		} finally {
+			BootstrapForm::switchBootstrapVersion(BootstrapVersion::V4);
+		}
+	}
+
+	/**
+	 * Blueprint hands the renderer a plain form; this is that capability on its own.
+	 */
+	public function testRendererDrawsPlainNetteForm(): void
+	{
+		$form = new Form();
+		$form->addText('field', 'Field');
+
+		$html = (new BootstrapRenderer())->render($form);
+
+		$this->assertStringContainsString('name="field"', $html);
+		$this->assertStringContainsString('class="form-group"', $html);
+	}
+
+	public function testClonedRendererDrawsPlainNetteForm(): void
+	{
+		$bootstrapForm = new BootstrapForm();
+		$bootstrapForm->addText('field', 'Field');
+
+		$form = new Form();
+		$form->addText('field', 'Field');
+		$form->setRenderer(clone $bootstrapForm->getRenderer());
+
+		ob_start();
+
+		try {
+			$form->render();
+			$html = (string) ob_get_contents();
+		} finally {
+			ob_end_clean();
+		}
+
+		$this->assertStringContainsString('name="field"', $html);
+		$this->assertStringContainsString('class="form-group"', $html);
+	}
+
+	public function testGeneratesDataClass(): void
+	{
+		$form = new BootstrapForm();
+		$form->addText('name', 'Name');
+		$form->addCheckbox('agree', 'Agree');
+
+		$dataClass = (new Blueprint())->generateDataClass($form);
+
+		$this->assertStringContainsString('public string $name', $dataClass);
+		$this->assertStringContainsString('public bool $agree', $dataClass);
+	}
+
+}
diff --git a/tests/Rendering/RenderedOptionTest.php b/tests/Rendering/RenderedOptionTest.php
new file mode 100644
index 0000000..9c62c0e
--- /dev/null
+++ b/tests/Rendering/RenderedOptionTest.php
@@ -0,0 +1,96 @@
+<?php declare (strict_types = 1);
+
+namespace Tests\Rendering;
+
+use Contributte\FormsBootstrap\BootstrapForm;
+use Contributte\FormsBootstrap\Enums\RendererOptions;
+use Nette\Application\UI\Presenter;
+use Tests\BaseTestCase;
+
+/**
+ * The renderer tracks what it has already drawn, so that a control belonging to a group is
+ * not drawn again by the trailing pass. It must not confuse that with Nette's own 'rendered'
+ * option, which BaseControl::getControl() sets on every fetch.
+ */
+class RenderedOptionTest extends BaseTestCase
+{
+
+	/** @var BootstrapForm */
+	private $form;
+
+	public function setUp(): void
+	{
+		$this->form = new BootstrapForm();
+		$this->form->setParent($this->createStub(Presenter::class));
+		$this->form->setAction('/');
+	}
+
+	public function testControlIsStillRenderedAfterItsControlHtmlWasFetched(): void
+	{
+		$this->form->addText('a', 'b');
+
+		// Nette sets its own 'rendered' option as a side effect of this
+		$this->form->getComponent('a')->getControl();
+
+		$this->assertStringContainsString('name="a"', $this->form->__toString(true));
+	}
+
+	/**
+	 * Assisted manual rendering: renderControls() called on its own, with no render() ahead
+	 * of it to reset anything. Fetching a control's html must not make it disappear.
+	 */
+	public function testAssistedRenderingIsNotDisturbedByFetchingControlHtml(): void
+	{
+		$this->form->addText('a', 'b');
+		$this->form->addText('c', 'd');
+
+		$renderer = $this->form->getRenderer();
+		$renderer->attachForm($this->form);
+
+		$this->form->getComponent('a')->getControl();
+
+		$html = $renderer->renderControls($this->form);
+
+		$this->assertStringContainsString('name="a"', $html);
+		$this->assertStringContainsString('name="c"', $html);
+	}
+
+	/**
+	 * The escape hatch of marking a control rendered by hand still works.
+	 */
+	public function testControlMarkedRenderedByHandIsSkipped(): void
+	{
+		$this->form->addText('a', 'b');
+		$this->form->addText('c', 'd');
+
+		$renderer = $this->form->getRenderer();
+		$renderer->attachForm($this->form);
+		$this->form->getComponent('a')->setOption(RendererOptions::_RENDERED, true);
+
+		$html = $renderer->renderControls($this->form);
+
+		$this->assertStringNotContainsString('name="a"', $html);
+		$this->assertStringContainsString('name="c"', $html);
+	}
+
+	public function testRenderingTwiceProducesTheSameOutput(): void
+	{
+		$this->form->addGroup('Group');
+		$this->form->addText('a', 'b');
+		$this->form->addSubmit('send', 'Send');
+
+		$this->assertSame($this->form->__toString(true), $this->form->__toString(true));
+	}
+
+	public function testGroupedControlIsNotRenderedTwice(): void
+	{
+		$this->form->addGroup('Group');
+		$this->form->addText('a', 'b');
+
+		$html = $this->form->__toString(true);
+
+		$this->assertSame(1, substr_count($html, 'name="a"'));
+		$this->assertTrue($this->form->getComponent('a')->getOption(RendererOptions::_RENDERED));
+	}
+
+}