diff --git a/examples/rp_pico/pio_ws2812/main.cpp b/examples/rp_pico/pio_ws2812/main.cpp
index a5e1699570..b03920beff 100644
--- a/examples/rp_pico/pio_ws2812/main.cpp
+++ b/examples/rp_pico/pio_ws2812/main.cpp
@@ -54,17 +54,17 @@ struct do_zero {};
 .wrap
 */
 // PIO program
-static constexpr auto pio_prog = modm::platform::PIOProgram::begin()
-	.sideset<1>()
-	.wrapTarget()
-	.label<bitloop>()
-		.instr(pio::Out().x<1>()				.side<0>().delay<TL_Common-1>())
-		.instr(pio::Jmp().not_x().to<do_zero>()	.side<1>().delay<TH_Common-1>())
-	.label<do_one>()
-		.instr(pio::Jmp().to<bitloop>()			.side<1>().delay<TH_Add-1>())
-	.label<do_zero>()
-		.instr(pio::Nop()						.side<0>().delay<TL_Add-1>())
-	.wrap()
+static constexpr auto pio_prog = PIOProgram::begin()
+	.sideset<1>
+	.wrapTarget<>
+	.label<bitloop>
+		.instr(pio::Out.x<1>				.side<0>.delay<TL_Common-1>)
+		.instr(pio::Jmp.not_x.to<do_zero>	.side<1>.delay<TH_Common-1>)
+	.label<do_one>
+		.instr(pio::Jmp.to<bitloop>			.side<1>.delay<TH_Add-1>)
+	.label<do_zero>
+		.instr(pio::Nop						.side<0>.delay<TL_Add-1>)
+	.wrap<>
 	.end();
 
 
diff --git a/src/modm/platform/pio/rp/pio.hpp.in b/src/modm/platform/pio/rp/pio.hpp.in
index 6cbf7852fe..fe688d8366 100644
--- a/src/modm/platform/pio/rp/pio.hpp.in
+++ b/src/modm/platform/pio/rp/pio.hpp.in
@@ -60,12 +60,12 @@ namespace modm::platform
         }
 
         template <typename Pio,size_t SM>
-        friend class pio::StateMachine;
+        friend class pio::implementation::StateMachine;
 
     public:
         static constexpr Peripheral peripherial = Peripheral::Pio{{ id }};
         template <size_t SM>
-        class StateMachine : public modm::platform::pio::StateMachine<Pio{{ id }},SM> {};
+        class StateMachine : public modm::platform::pio::implementation::StateMachine<Pio{{ id }},SM> {};
 
         template< class... Signals >
         static void
diff --git a/src/modm/platform/pio/rp/pio_asm.hpp b/src/modm/platform/pio/rp/pio_asm.hpp
index ddf9bd29f7..983f55e0e3 100644
--- a/src/modm/platform/pio/rp/pio_asm.hpp
+++ b/src/modm/platform/pio/rp/pio_asm.hpp
@@ -17,359 +17,425 @@
 
 namespace modm::platform::pio
 {
+	namespace implementation
+	{
+		struct Instruction {
+			uint16_t value;
+			constexpr Instruction(uint16_t val) : value(val) {}
+			constexpr uint16_t store(size_t offset) const {
+				return ((value & 0xe000) == 0x0000) ? (value + offset) : value;
+			}
+			constexpr Instruction operator | (uint16_t params) const {
+				return Instruction(value | params);
+			}
+			constexpr bool operator == (uint16_t val) const {
+				return value == val;
+			}
+		};
 
-	struct Instruction {
-		uint16_t value;
-		constexpr Instruction(uint16_t val) : value(val) {}
-		constexpr uint16_t store(size_t offset) const {
-			return ((value & 0xe000) == 0x0000) ? (value + offset) : value;
-		}
-		constexpr Instruction operator | (uint16_t params) const {
-			return Instruction(value | params);
-		}
-		constexpr bool operator == (uint16_t val) const {
-			return value == val;
-		}
-	};
-
-	enum class Opcode : uint16_t {
-		JMP 	= 0x0000 << 13,
-		WAIT 	= 0x0001 << 13,
-		IN 		= 0x0002 << 13,
-		OUT 	= 0x0003 << 13,
-		PUSH 	= 0x0004 << 13,
-		PULL 	= (0x0004 << 13) | (0x0001 << 7),
-		MOV 	= 0x0005 << 13,
-		IRQ 	= 0x0006 << 13,
-		SET 	= 0x0007 << 13,
-	};
-
-	struct OptionalValue {
-		uint16_t value{0};
-		bool is_set{false};
-	};
-
-	static constexpr uint16_t NO_SIDE_VALUE = 0xffff;
-
-	template <uint16_t side = NO_SIDE_VALUE,uint16_t delay = 0>
-	struct SideDelay {
-		static constexpr const uint16_t side_value = (side == NO_SIDE_VALUE) ? 0 : side;
-		static constexpr const bool side_value_present = side != NO_SIDE_VALUE;
-		static constexpr const uint16_t delay_value = delay;
-	};
-
-	template <typename Res>
-	struct InstructionEncoding {
-		static constexpr const Opcode opcode = Res::opcode;
-		static constexpr const uint16_t DELAY_SIDESET_SHIFT = 8;
-		static constexpr const uint16_t DELAY_SIDESET_MASK = 0x1f << DELAY_SIDESET_SHIFT;
-		static constexpr const uint16_t ARG1_SHIFT = 5;
-
-		using SideDelayConfig = SideDelay<>;
-
-		template <uint16_t side = 0>
-		struct SideValue : Res {
-			using SideDelayConfig = SideDelay<side,0>;
-			constexpr SideValue() {}
+		enum class Opcode : uint16_t {
+			JMP 	= 0x0000 << 13,
+			WAIT 	= 0x0001 << 13,
+			IN 		= 0x0002 << 13,
+			OUT 	= 0x0003 << 13,
+			PUSH 	= 0x0004 << 13,
+			PULL 	= (0x0004 << 13) | (0x0001 << 7),
+			MOV 	= 0x0005 << 13,
+			IRQ 	= 0x0006 << 13,
+			SET 	= 0x0007 << 13,
+		};
+
+		struct OptionalValue {
+			uint16_t value{0};
+			bool is_set{false};
+		};
+
+		static constexpr uint16_t NO_SIDE_VALUE = 0xffff;
+
+		template <uint16_t side = NO_SIDE_VALUE,uint16_t delay = 0>
+		struct SideDelay {
+			static constexpr const uint16_t side_value = (side == NO_SIDE_VALUE) ? 0 : side;
+			static constexpr const bool side_value_present = side != NO_SIDE_VALUE;
+			static constexpr const uint16_t delay_value = delay;
+		};
+
+		template <typename Res>
+		struct InstructionEncoding {
+			static constexpr const Opcode opcode = Res::opcode;
+			static constexpr const uint16_t DELAY_SIDESET_SHIFT = 8;
+			static constexpr const uint16_t DELAY_SIDESET_MASK = 0x1f << DELAY_SIDESET_SHIFT;
+			static constexpr const uint16_t ARG1_SHIFT = 5;
+
+			using SideDelayConfig = SideDelay<>;
+
+			template <uint16_t side = 0>
+			struct SideValue : Res {
+				using SideDelayConfig = SideDelay<side,0>;
+				constexpr SideValue() {}
+				template <uint16_t delay = 0>
+				struct DelayValue : Res {
+					constexpr DelayValue() {}
+					using SideDelayConfig = SideDelay<side,delay>;
+					template <typename Encoder>
+					static constexpr Instruction encode(const Encoder& coder) {
+						return Res::encode(coder) | (coder.template encodeSideDelay<SideDelayConfig>() << DELAY_SIDESET_SHIFT);
+					}
+				};
+				template <uint16_t val>
+				static constexpr auto delay = DelayValue<val>();
+
+				template <typename Encoder>
+				static constexpr Instruction encode(const Encoder& coder)  {
+					return Res::encode(coder) | (coder.template encodeSideDelay<SideDelayConfig>() << DELAY_SIDESET_SHIFT);
+				}
+			};
 			template <uint16_t delay = 0>
 			struct DelayValue : Res {
 				constexpr DelayValue() {}
-				using SideDelayConfig = SideDelay<side,delay>;
+				using SideDelayConfig = SideDelay<NO_SIDE_VALUE,delay>;
 				template <typename Encoder>
-				constexpr Instruction encode(const Encoder& coder) const {
+				static constexpr Instruction encode(const Encoder& coder)  {
 					return Res::encode(coder) | (coder.template encodeSideDelay<SideDelayConfig>() << DELAY_SIDESET_SHIFT);
 				}
 			};
+
+			constexpr InstructionEncoding()  {}
 			template <uint16_t val>
-			constexpr auto delay() {
-				return DelayValue<val>();
-			}
-			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
-				return Res::encode(coder) | (coder.template encodeSideDelay<SideDelayConfig>() << DELAY_SIDESET_SHIFT);
-			}
-		};
-		template <uint16_t delay = 0>
-		struct DelayValue : Res {
-			constexpr DelayValue() {}
-			using SideDelayConfig = SideDelay<NO_SIDE_VALUE,delay>;
+			static constexpr auto side = SideValue<val>();
+			template <uint16_t val>
+			static constexpr auto delay = DelayValue<val>();
+
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
-				return Res::encode(coder) | (coder.template encodeSideDelay<SideDelayConfig>() << DELAY_SIDESET_SHIFT);
+			static constexpr Instruction encode(const Encoder& ) {
+				return Instruction(uint16_t(opcode));
 			}
 		};
 
-		constexpr InstructionEncoding()  {}
-		template <uint16_t val>
-		constexpr auto side() const {
-			return SideValue<val>();
-		}
-		template <uint16_t val>
-		constexpr auto delay() {
-			return DelayValue<val>();
-		}
-		template <typename Encoder>
-		constexpr Instruction encode(const Encoder& ) const {
-			return Instruction(uint16_t(opcode));
+		template <typename T>
+		static constexpr bool check(const T& t,uint16_t value) {
+			struct Encoder {
+				constexpr uint16_t encodeSideDelay(const OptionalValue& /*side*/,uint16_t /*delay*/) const {
+					return 0;
+				}
+			};
+			return t.encode(Encoder()) == value;
 		}
-	};
-
-	enum class JmpCondition : uint16_t {
-		ALWAYS 	= 0x00,
-		NOT_X 	= 0x01,
-		X_DEC 	= 0x02,
-		NOT_Y	= 0x03,
-		Y_DEC 	= 0x04,
-		X_NE_Y	= 0x05,
-		PIN 	= 0x06,
-		NOT_ORSE = 0x07,
-	};
-	template <typename Label = void,JmpCondition condition = JmpCondition::ALWAYS,uint16_t addr = 0x0000>
-	struct Jmp : InstructionEncoding<Jmp<Label,condition,addr>> {
-		static constexpr const Opcode opcode = Opcode::JMP;
-		static constexpr const JmpCondition condition_value = condition;
-		static constexpr const uint16_t addr_value = addr;
-		static_assert(addr_value < 0x0f, "Invalid addr");
-
-		using LabelName = Label;
-		using Base = InstructionEncoding<Jmp<Label,condition,addr>>;
-
-		explicit constexpr Jmp() {}
-		static constexpr auto not_x() { return Jmp<LabelName,JmpCondition::NOT_X,addr_value>(); }
-		static constexpr auto x_dec() { return Jmp<LabelName,JmpCondition::X_DEC,addr_value>(); }
-		static constexpr auto not_y() { return Jmp<LabelName,JmpCondition::NOT_Y,addr_value>(); }
-		static constexpr auto y_dec() { return Jmp<LabelName,JmpCondition::Y_DEC,addr_value>(); }
-		static constexpr auto x_ne_y() { return Jmp<LabelName,JmpCondition::X_NE_Y,addr_value>(); }
-		static constexpr auto pin() { return Jmp<LabelName,JmpCondition::PIN,addr_value>(); }
-		static constexpr auto not_osre() { return Jmp<LabelName,JmpCondition::NOT_ORSE,addr_value>(); }
-
-		template <typename ToLabel>
-		static constexpr auto to() { return Jmp<ToLabel,condition_value,addr_value>(); }
-
-		template <typename Encoder>
-		static constexpr uint16_t getAddr(const Encoder& coder) {
+
+		enum class JmpCondition : uint16_t {
+			ALWAYS 	= 0x00,
+			NOT_X 	= 0x01,
+			X_DEC 	= 0x02,
+			NOT_Y	= 0x03,
+			Y_DEC 	= 0x04,
+			X_NE_Y	= 0x05,
+			PIN 	= 0x06,
+			NOT_ORSE = 0x07,
+		};
+		template <typename Label,typename Encoder>
+		static constexpr uint16_t getJmpAddr(const Encoder& coder,uint16_t addr_value) {
 			if constexpr (std::is_same_v<Label,void>) {
 				return addr_value;
 			} else {
 				return coder.template getOffset<Label>();
 			}
 		}
+		template <typename Label = void,uint16_t addr = 0x0000>
+		struct Jmp : InstructionEncoding<Jmp<Label,addr>> {
+			static constexpr const Opcode opcode = Opcode::JMP;
+			static constexpr const JmpCondition condition_value = JmpCondition::ALWAYS;
+			static constexpr const uint16_t addr_value = addr;
+			static_assert(addr_value < 0x0f, "Invalid addr");
+
+			using LabelName = Label;
+			using Base = InstructionEncoding<Jmp<Label,addr>>;
+
+			template <JmpCondition condition,typename LabelImpl = Label>
+			struct JmpImpl : InstructionEncoding<JmpImpl<condition>>{
+				static constexpr const Opcode opcode = Opcode::JMP;
+				static constexpr const JmpCondition condition_value = condition;
+				static constexpr const uint16_t addr_value = addr;
+				using LabelName = LabelImpl;
+				using Base = InstructionEncoding<JmpImpl<condition>>;
+				constexpr JmpImpl() {}
+				template <typename Encoder>
+				static constexpr Instruction encode(const Encoder& coder) {
+					return Base::encode(coder) | (uint16_t(condition_value) << Base::ARG1_SHIFT) | getJmpAddr<LabelName>(coder,addr_value);
+				}
+				template <typename ToLabel>
+				static constexpr auto to = JmpImpl<condition_value,ToLabel>(); 
+			};
 
-		template <typename Encoder>
-		constexpr Instruction encode(const Encoder& coder) const {
-			return Base::encode(coder) | (uint16_t(condition_value) << Base::ARG1_SHIFT) | getAddr(coder);
-		}
-
-	};
+			explicit constexpr Jmp() {}
+			static constexpr auto not_x = JmpImpl<JmpCondition::NOT_X>();
+			static constexpr auto x_dec = JmpImpl<JmpCondition::X_DEC>();
+			static constexpr auto not_y = JmpImpl<JmpCondition::NOT_Y>();
+			static constexpr auto y_dec = JmpImpl<JmpCondition::Y_DEC>();
+			static constexpr auto x_ne_y = JmpImpl<JmpCondition::X_NE_Y>();
+			static constexpr auto pin = JmpImpl<JmpCondition::PIN>(); 
+			static constexpr auto not_osre = JmpImpl<JmpCondition::NOT_ORSE>();
 
-	enum class WaitSource : uint16_t {
-		GPIO 		= 0x00,
-		PIN 		= 0x01,
-		IRQ 		= 0x02
-	};
-	template <int polarity>
-	struct Wait  {
-		static_assert(polarity == 0 || polarity == 1, "Invalid polarity");
+			template <typename ToLabel>
+			static constexpr auto to = Jmp<ToLabel,addr_value>();
 
-		// @todo relative syntax
-		template <WaitSource source,uint16_t index>
-		struct WaitImpl : InstructionEncoding<WaitImpl<source,index>> {
-			static constexpr const Opcode opcode = Opcode::WAIT;
-			using Base = InstructionEncoding<WaitImpl<source,index>>;
-			static constexpr WaitSource source_value = source;
-			static constexpr uint16_t polarity_value = polarity;
-			static constexpr uint16_t index_value = index;
-			explicit constexpr WaitImpl() {}
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
-				return Base::encode(coder) |
-					(polarity_value << 7) |
-					(uint16_t(source_value) << Base::ARG1_SHIFT) |
-					index_value;
+			static constexpr Instruction encode(const Encoder& coder) {
+				return Base::encode(coder) | (uint16_t(condition_value) << Base::ARG1_SHIFT) | getJmpAddr<LabelName>(coder,addr_value);
 			}
+
+		};
+
+
+
+		enum class WaitSource : uint16_t {
+			GPIO 		= 0x00,
+			PIN 		= 0x01,
+			IRQ 		= 0x02
+		};
+		template <int polarity>
+		struct Wait  {
+			static_assert(polarity == 0 || polarity == 1, "Invalid polarity");
+
+			// @todo relative syntax
+			template <WaitSource source,uint16_t index>
+			struct WaitImpl : InstructionEncoding<WaitImpl<source,index>> {
+				static constexpr const Opcode opcode = Opcode::WAIT;
+				using Base = InstructionEncoding<WaitImpl<source,index>>;
+				static constexpr WaitSource source_value = source;
+				static constexpr uint16_t polarity_value = polarity;
+				static constexpr uint16_t index_value = index;
+				explicit constexpr WaitImpl() {}
+				template <typename Encoder>
+				static constexpr Instruction encode(const Encoder& coder) {
+					return Base::encode(coder) |
+						(polarity_value << 7) |
+						(uint16_t(source_value) << Base::ARG1_SHIFT) |
+						index_value;
+				}
+			};
+
+			explicit constexpr Wait() {}
+			template <uint16_t gpio_num>
+			static constexpr auto gpio = WaitImpl<WaitSource::GPIO,gpio_num>();
+			template <uint16_t pin_num>
+			static constexpr auto pin = WaitImpl<WaitSource::PIN,pin_num>();
+			template <uint16_t irq_num>
+			static constexpr auto irq = WaitImpl<WaitSource::IRQ,irq_num>();
+		};
+		
+
+		enum class InSource : uint16_t {
+			PINS 		= 0x00,
+			X 			= 0x01,
+			Y 			= 0x02,
+			NULL_T 		= 0x03,
+			ISR 		= 0x06,
+			OSR 		= 0x07,
+		};
+		struct In {
+			// @todo
+			template <InSource source,uint16_t bits>
+			struct InImpl : InstructionEncoding<InImpl<source,bits>> {
+				static_assert(bits >= 1 && bits <= 32,"Invalid bits count");
+				static constexpr const Opcode opcode = Opcode::IN;
+				using Base = InstructionEncoding<InImpl<source,bits>>;
+				static constexpr InSource source_value = source;
+				static constexpr uint16_t bits_value = bits == 32 ? 0 : bits;
+				explicit constexpr InImpl() {}
+				template <typename Encoder>
+				static constexpr Instruction encode(const Encoder& coder) {
+					return Base::encode(coder) |
+						(uint16_t(source_value) << Base::ARG1_SHIFT) |
+						bits_value;
+				}
+			};
+			explicit constexpr In() {}
+			template <uint16_t bits>
+			static constexpr auto pins = InImpl<InSource::PINS,bits>();
+			template <uint16_t bits>
+			static constexpr auto x = InImpl<InSource::X,bits>();
+			template <uint16_t bits>
+			static constexpr auto y = InImpl<InSource::Y,bits>();
+			template <uint16_t bits>
+			static constexpr auto null = InImpl<InSource::NULL_T,bits>();
+			template <uint16_t bits>
+			static constexpr auto isr = InImpl<InSource::ISR,bits>();
+			template <uint16_t bits>
+			static constexpr auto osr = InImpl<InSource::OSR,bits>();
+		};
+
+		enum class OutDestination : uint16_t {
+			PINS 	= 0x00,
+			X 		= 0x01,
+			Y 		= 0x02,
+			NULL_T 	= 0x03,
+			PINDIRS = 0x04,
+			PC 		= 0x05,
+			ISR 	= 0x06,
+			EXEC 	= 0x07,
+		};
+
+		struct Out {
+			template <OutDestination destination,uint16_t bits>
+			struct OutImpl : InstructionEncoding<OutImpl<destination,bits>> {
+				using Base = InstructionEncoding<OutImpl<destination,bits>>;
+				static_assert(bits >= 1 && bits <= 32,"Invalid bits count");
+				static constexpr const Opcode opcode = Opcode::OUT;
+				static constexpr OutDestination destination_value = destination;
+				static constexpr uint16_t bits_value = bits == 32 ? 0 : bits;
+				constexpr OutImpl() {}
+				template <typename Encoder>
+				static constexpr Instruction encode(const Encoder& coder) {
+					return Base::encode(coder) |
+						(uint16_t(destination_value) << Base::ARG1_SHIFT) |
+						bits_value;
+				}
+			};
+
+			template <uint16_t nbits>
+			static constexpr auto pins = OutImpl<OutDestination::PINS,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto x = OutImpl<OutDestination::X,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto y = OutImpl<OutDestination::Y,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto null = OutImpl<OutDestination::NULL_T,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto pindirs = OutImpl<OutDestination::PINDIRS,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto pc = OutImpl<OutDestination::PC,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto isr = OutImpl<OutDestination::ISR,nbits>();
+			template <uint16_t nbits>
+			static constexpr auto exec = OutImpl<OutDestination::EXEC,nbits>();
+
 		};
 
-		explicit constexpr Wait() {}
-		template <uint16_t gpio_num>
-		static constexpr auto gpio() { return WaitImpl<WaitSource::GPIO,gpio_num>(); }
-		template <uint16_t pin_num>
-		static constexpr auto pin() { return WaitImpl<WaitSource::PIN,pin_num>(); }
-		template <uint16_t irq_num>
-		static constexpr auto irq() { return WaitImpl<WaitSource::PIN,irq_num>(); }
-	};
-
-	enum class InSource : uint16_t {
-		PINS 		= 0x00,
-		X 			= 0x01,
-		Y 			= 0x02,
-		NULL_T 		= 0x03,
-		ISR 		= 0x06,
-		OSR 		= 0x07,
-	};
-	struct In {
-		template <InSource source,uint16_t bits>
-		struct InImpl : InstructionEncoding<InImpl<source,bits>> {
-			static_assert(bits >= 1 && bits <= 32,"Invalid bits count");
-			static constexpr const Opcode opcode = Opcode::IN;
-			using Base = InstructionEncoding<InImpl<source,bits>>;
-			static constexpr InSource source_value = source;
-			static constexpr uint16_t bits_value = bits == 32 ? 0 : bits;
-			explicit constexpr InImpl() {}
+
+		template <bool IfFull,bool Block>
+		struct PushImpl : InstructionEncoding<PushImpl<IfFull,Block>> {
+			using Base = InstructionEncoding<PushImpl<IfFull,Block>>;
+			static constexpr const Opcode opcode = Opcode::PUSH;
+			static constexpr const bool iffull_value = IfFull;
+			static constexpr const bool block_value = Block;
+			constexpr PushImpl() {}
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
-				return Base::encode(coder) |
-					(uint16_t(source_value) << Base::ARG1_SHIFT) |
-					bits_value;
+			static constexpr Instruction encode(const Encoder& coder) {
+				return Base::encode(coder) | (iffull_value ? (1<<6) : 0) | (block_value ? (1<<5) : 0);
 			}
 		};
-		explicit constexpr In() {}
-	};
-	enum class OutDestination : uint16_t {
-		PINS 	= 0x00,
-		X 		= 0x01,
-		Y 		= 0x02,
-		NULL_T 	= 0x03,
-		PINDIRS = 0x04,
-		PC 		= 0x05,
-		ISR 	= 0x06,
-		EXEC 	= 0x07,
-	};
-
-	struct Out {
-		template <OutDestination destination,uint16_t bits>
-		struct OutImpl : InstructionEncoding<OutImpl<destination,bits>> {
-			using Base = InstructionEncoding<OutImpl<destination,bits>>;
-			static_assert(bits >= 1 && bits <= 32,"Invalid bits count");
-			static constexpr const Opcode opcode = Opcode::OUT;
-			static constexpr OutDestination destination_value = destination;
-			static constexpr uint16_t bits_value = bits == 32 ? 0 : bits;
-			constexpr OutImpl() {}
+		struct PushImplIF : PushImpl<true,true> {
+			constexpr PushImplIF() {}
+
+			static constexpr auto block = PushImpl<true,true>();
+			static constexpr auto noblock = PushImpl<true,false>();
+		};
+		struct Push : PushImpl<false,true> {
+			constexpr Push() {}
+			
+			static constexpr auto iffull = PushImplIF();
+			static constexpr auto block = PushImpl<false,true>();
+			static constexpr auto noblock = PushImpl<false,false>();
+		};
+
+		template <bool IfEmpty, bool Block>
+		struct PullImpl : InstructionEncoding<PullImpl<IfEmpty,Block>> {
+			static constexpr const Opcode opcode = Opcode::PULL;
+			using Base = InstructionEncoding<PullImpl<IfEmpty,Block>>;
+			static constexpr const bool ifempty_value = IfEmpty;
+			static constexpr const bool block_value = Block;
+			constexpr PullImpl()  {}
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
-				return Base::encode(coder) |
-					(uint16_t(destination_value) << Base::ARG1_SHIFT) |
-					bits_value;
+			static constexpr Instruction encode(const Encoder& coder) {
+				return Base::encode(coder) | (ifempty_value ? (1<<6) : 0) | (block_value ? (1<<5) : 0);
 			}
 		};
+		struct PullImplIE : PullImpl<true,true> {
+			constexpr PullImplIE() {}
+			static constexpr auto block = PullImpl<true,true>();
+			static constexpr auto noblock = PullImpl<true,false>();
+		};
+		struct Pull : PullImpl<false,true> {
+			constexpr Pull() {}
+			static constexpr auto ifempty = PullImplIE();
+			static constexpr auto block = PullImpl<false,true>();
+			static constexpr auto noblock = PullImpl<false,false>();
+		};
 
-		template <uint16_t nbits>
-		constexpr auto pins() { return OutImpl<OutDestination::PINS,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto x() { return OutImpl<OutDestination::X,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto y() { return OutImpl<OutDestination::Y,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto null() { return OutImpl<OutDestination::NULL_T,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto pindirs() { return OutImpl<OutDestination::PINDIRS,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto pc() { return OutImpl<OutDestination::PC,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto isr() { return OutImpl<OutDestination::ISR,nbits>(); }
-		template <uint16_t nbits>
-		constexpr auto exec() { return OutImpl<OutDestination::EXEC,nbits>(); }
-
-	};
-
-	template <bool IfFull = false, bool Block = true>
-	struct Push : InstructionEncoding<Push<IfFull,Block>> {
-		static constexpr const Opcode opcode = Opcode::PUSH;
-		using Base = InstructionEncoding<Push<IfFull,Block>>;
-		static constexpr const bool iffull_value = IfFull;
-		static constexpr const bool block_value = Block;
-		constexpr Push() {}
-		constexpr auto iffull() { return Push<true,block_value>(); }
-		constexpr auto block() { return Push<iffull_value,true>(); }
-		constexpr auto noblock() { return Push<iffull_value,false>(); }
-		template <typename Encoder>
-		constexpr Instruction encode(const Encoder& coder) const {
-			return Base::encode(coder) | (iffull_value ? (1<<6) : 0) | (block_value ? (1<<5) : 0);
-		}
-	};
-	template <bool IfEmpty = false, bool Block = true>
-	struct Pull : InstructionEncoding<Pull<IfEmpty,Block>> {
-		static constexpr const Opcode opcode = Opcode::PULL;
-		using Base = InstructionEncoding<Pull<IfEmpty,Block>>;
-		static constexpr const bool ifempty_value = IfEmpty;
-		static constexpr const bool block_value = Block;
-		constexpr Pull()  {}
-		constexpr auto ifempty() { return Pull<true,block_value>(); }
-		constexpr auto block() { return Pull<ifempty_value,true>(); }
-		constexpr auto noblock() { return Pull<ifempty_value,false>(); }
-		template <typename Encoder>
-		constexpr Instruction encode(const Encoder& coder) const {
-			return Base::encode(coder) | (ifempty_value ? (1<<6) : 0) | (block_value ? (1<<5) : 0);
-		}
-	};
-
-	enum class MovDestination : uint16_t {
-		PINS 	= 0x00,
-		X 		= 0x01,
-		Y 		= 0x02,
-		EXEC 	= 0x04,
-		PC 		= 0x05,
-		ISR 	= 0x06,
-		OSR 	= 0x07,
-	};
-
-	enum class MovSource : uint16_t {
-		PINS 	= 0x00,
-		X 		= 0x01,
-		Y 		= 0x02,
-		NULL_T 	= 0x03,
-		STATUS 	= 0x05,
-		ISR 	= 0x06,
-		OSR 	= 0x07,
-	};
-
-	enum class MovOperation : uint16_t {
-		NONE 	= 0x00,
-		INVERT 	= 0x01,
-		REVERSE = 0x02,
-	};
-
-	struct Mov {
-		template <MovDestination destination,MovOperation operation = MovOperation::NONE>
-		struct MovDst  {
-			template <MovSource source>
-			struct MovImpl : InstructionEncoding<MovImpl<source>> {
-				static constexpr const Opcode opcode = Opcode::MOV;
-				static constexpr MovSource source_value = source;
-				static constexpr MovDestination destination_value = destination;
-				static constexpr MovOperation operation_value = operation;
-
-				static constexpr size_t OP_SHIFT = 3;
-				static constexpr size_t DESTINATION_SHIFT = 5;
-				template <typename Encoder>
-				constexpr Instruction encode(const Encoder& coder) const {
-					return InstructionEncoding<MovImpl<source>>::encode(coder) | uint16_t(source_value) |
-						(uint16_t(operation_value)<<OP_SHIFT) |
-						(uint16_t(destination_value) << DESTINATION_SHIFT);
-				}
-			};
+		enum class MovDestination : uint16_t {
+			PINS 	= 0x00,
+			X 		= 0x01,
+			Y 		= 0x02,
+			EXEC 	= 0x04,
+			PC 		= 0x05,
+			ISR 	= 0x06,
+			OSR 	= 0x07,
+		};
 
-			static constexpr auto invert() { return MovDst<destination,MovOperation::INVERT>(); }
-			static constexpr auto reverse() { return MovDst<destination,MovOperation::REVERSE>(); }
+		enum class MovSource : uint16_t {
+			PINS 	= 0x00,
+			X 		= 0x01,
+			Y 		= 0x02,
+			NULL_T 	= 0x03,
+			STATUS 	= 0x05,
+			ISR 	= 0x06,
+			OSR 	= 0x07,
+		};
 
-			static  constexpr auto pins() { return MovImpl<MovSource::PINS>(); }
-			static  constexpr auto x() { return MovImpl<MovSource::X>(); }
-			static  constexpr auto y() { return MovImpl<MovSource::Y>(); }
-			static  constexpr auto null() { return MovImpl<MovSource::NULL_T>(); }
-			static  constexpr auto status() { return MovImpl<MovSource::STATUS>(); }
-			static  constexpr auto isr() { return MovImpl<MovSource::ISR>(); }
-			static  constexpr auto osr() { return MovImpl<MovSource::OSR>(); }
+		enum class MovOperation : uint16_t {
+			NONE 	= 0x00,
+			INVERT 	= 0x01,
+			REVERSE = 0x02,
 		};
 
-		static constexpr auto pins()  { return MovDst<MovDestination::PINS>(); }
-		static constexpr auto x()  { return MovDst<MovDestination::X>(); }
-		static constexpr auto y()  { return MovDst<MovDestination::Y>(); }
-		static constexpr auto exec()  { return MovDst<MovDestination::EXEC>(); }
-		static constexpr auto pc()  { return MovDst<MovDestination::PC>(); }
-		static constexpr auto isr()  { return MovDst<MovDestination::ISR>(); }
-		static constexpr auto osr()  { return MovDst<MovDestination::OSR>(); }
-	};
+		template <MovDestination destination,MovOperation operation,MovSource source>
+		struct MovImpl : InstructionEncoding<MovImpl<destination,operation,source>> {
+			using Base = InstructionEncoding<MovImpl<destination,operation,source>>;
+			static constexpr const Opcode opcode = Opcode::MOV;
+			static constexpr MovSource source_value = source;
+			static constexpr MovDestination destination_value = destination;
+			static constexpr MovOperation operation_value = operation;
+			static constexpr size_t OP_SHIFT = 3;
+			static constexpr size_t DESTINATION_SHIFT = 5;
+			template <typename Encoder>
+			static constexpr Instruction encode(const Encoder& coder) {
+				return Base::encode(coder) | uint16_t(source_value) |
+						(uint16_t(operation_value)<<OP_SHIFT) |
+						(uint16_t(destination_value) << DESTINATION_SHIFT);
+			}
+		};
+		template <MovDestination destination,MovOperation operation>
+		struct MovDstOp {
+			static  constexpr auto pins = MovImpl<destination,operation,MovSource::PINS>();
+			static  constexpr auto x = MovImpl<destination,operation,MovSource::X>();
+			static  constexpr auto y = MovImpl<destination,operation,MovSource::Y>();
+			static  constexpr auto null = MovImpl<destination,operation,MovSource::NULL_T>();
+			static  constexpr auto status = MovImpl<destination,operation,MovSource::STATUS>();
+			static  constexpr auto isr = MovImpl<destination,operation,MovSource::ISR>();
+			static  constexpr auto osr = MovImpl<destination,operation,MovSource::OSR>();
+		};
+		template <MovDestination destination>
+		struct MovDst {
+			static  constexpr auto pins = MovImpl<destination,MovOperation::NONE,MovSource::PINS>();
+			static  constexpr auto x = MovImpl<destination,MovOperation::NONE,MovSource::X>();
+			static  constexpr auto y = MovImpl<destination,MovOperation::NONE,MovSource::Y>();
+			static  constexpr auto null = MovImpl<destination,MovOperation::NONE,MovSource::NULL_T>();
+			static  constexpr auto status = MovImpl<destination,MovOperation::NONE,MovSource::STATUS>();
+			static  constexpr auto isr = MovImpl<destination,MovOperation::NONE,MovSource::ISR>();
+			static  constexpr auto osr = MovImpl<destination,MovOperation::NONE,MovSource::OSR>();
+
+			static constexpr auto invert = MovDstOp<destination,MovOperation::INVERT>();
+			static constexpr auto reverse = MovDstOp<destination,MovOperation::REVERSE>();
+		};
+		struct Mov {
+			static constexpr auto pins = MovDst<MovDestination::PINS>();
+			static constexpr auto x = MovDst<MovDestination::X>();
+			static constexpr auto y = MovDst<MovDestination::Y>();
+			static constexpr auto exec = MovDst<MovDestination::EXEC>();
+			static constexpr auto pc = MovDst<MovDestination::PC>();
+			static constexpr auto isr = MovDst<MovDestination::ISR>();
+			static constexpr auto osr = MovDst<MovDestination::OSR>();
+		};
 
-	struct Irq {
 		// @todo relative syntax
 		template <bool clear,bool wait,uint16_t index>
 		struct IrqImpl : InstructionEncoding<IrqImpl<clear,wait,index>> {
@@ -380,32 +446,32 @@ namespace modm::platform::pio
 			static constexpr uint16_t index_value = index;
 			explicit constexpr IrqImpl() {}
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
+			static constexpr Instruction encode(const Encoder& coder) {
 				return Base::encode(coder) |
 					(clear_value ? (1<<6) : 0) |
 					(wait_value ? (1<<5) : 0) |
 					index_value;
 			}
 		};
-		constexpr Irq() {}
-		template <uint16_t index>
-		static constexpr auto set() { return IrqImpl<false,false,index>(); }
-		template <uint16_t index>
-		static constexpr auto nowait() { return IrqImpl<false,false,index>(); }
-		template <uint16_t index>
-		static constexpr auto wait() { return IrqImpl<false,true,index>(); }
-		template <uint16_t index>
-		static constexpr auto clear() { return IrqImpl<true,false,index>(); }
-	};
-
-	enum class SetDestination : uint16_t{
-		PINS 	= 0x00,
-		X 		= 0x01,
-		Y 		= 0x02,
-		PINDIRS = 0x04,
-	};
-
-	struct Set {
+
+		struct Irq {
+			constexpr Irq() {}
+			template <uint16_t index>
+			static constexpr auto set = IrqImpl<false,false,index>();
+			template <uint16_t index>
+			static constexpr auto nowait = IrqImpl<false,false,index>();
+			template <uint16_t index>
+			static constexpr auto wait = IrqImpl<false,true,index>();
+			template <uint16_t index>
+			static constexpr auto clear = IrqImpl<true,false,index>();
+		};
+
+		enum class SetDestination : uint16_t{
+			PINS 	= 0x00,
+			X 		= 0x01,
+			Y 		= 0x02,
+			PINDIRS = 0x04,
+		};
 		template <SetDestination destination,uint16_t value>
 		struct SetImpl : InstructionEncoding<SetImpl<destination,value>> {
 			static_assert(value <= 31,"invalid data value");
@@ -413,242 +479,349 @@ namespace modm::platform::pio
 			static constexpr SetDestination destination_value = destination;
 			static constexpr uint16_t data_value = value;
 			static constexpr size_t DESTINATION_SHIFT = 5;
+			constexpr SetImpl() {}
 			template <typename Encoder>
-			constexpr Instruction encode(const Encoder& coder) const {
+			static constexpr Instruction encode(const Encoder& coder) {
 				return InstructionEncoding<SetImpl<destination,value>>::encode(coder) | data_value |
 					(uint16_t(destination_value) << DESTINATION_SHIFT);
 			}
 		};
+		struct Set {
+			constexpr Set()  {}
+			template <size_t data>
+			static constexpr auto pins = SetImpl<SetDestination::PINS,data>();
+			template <size_t data>
+			static constexpr auto x = SetImpl<SetDestination::X,data>();
+			template <size_t data>
+			static constexpr auto y = SetImpl<SetDestination::Y,data>();
+			template <size_t data>
+			static constexpr auto pindirs = SetImpl<SetDestination::PINDIRS,data>();
+		};
 
-		constexpr Set()  {}
-		template <size_t data>
-		static constexpr auto pins() { return SetImpl<SetDestination::PINS,data>(); }
-		template <size_t data>
-		static constexpr auto x() { return SetImpl<SetDestination::X,data>(); }
-		template <size_t data>
-		static constexpr auto y() { return SetImpl<SetDestination::Y,data>(); }
-		template <size_t data>
-		static constexpr auto pindirs() { return SetImpl<SetDestination::PINDIRS,data>(); }
-
-	};
 
-	static inline constexpr auto Nop() {
-		return Mov().y().y();
-	}
+		template <typename ...Labels>
+		struct LabelsList;
 
-	template <typename ...Labels>
-	struct LabelsList;
+		template <typename Settings,typename Labels,typename Instructions,typename WrapSettings>
+		struct ProgramBuilder;
 
-	template <typename Settings,typename Labels,typename Instructions>
-	struct ProgramBuilder;
+		template <typename Name,size_t Offset>
+		struct Label {
+			using name = Name;
+			static constexpr size_t offset = Offset;
+		};
 
-	template <typename Name,size_t Offset>
-	struct Label {
-		using name = Name;
-		static constexpr size_t offset = Offset;
-	};
+		template <>
+		struct LabelsList<> {
+			template <typename Name,size_t offset>
+			struct add_s {
+				using result = LabelsList<Label<Name,offset> >;
+			};
+			template <typename Name,size_t offset>
+			using add = typename add_s<Name,offset>::result;
 
-	template <>
-	struct LabelsList<> {
-		template <typename Name,size_t offset>
-		struct add_s {
-			using result = LabelsList<Label<Name,offset> >;
+			template <typename Name>
+			static constexpr bool exist() {
+				return false;
+			}
 		};
-		template <typename Name,size_t offset>
-		using add = typename add_s<Name,offset>::result;
 
-		template <typename Name>
-		static constexpr bool exist() {
-			return false;
-		}
-	};
-
-	template <typename FirstLabel,typename ...Labels>
-	struct LabelsList<FirstLabel,Labels...> {
-		template <typename Name>
-		static constexpr size_t find(){
-			if constexpr (std::is_same_v<Name,typename FirstLabel::name>) {
-				return FirstLabel::offset;
-			} else {
-				static_assert(sizeof ...(Labels)!=0,"Not found label");
-				return LabelsList<Labels...>::template find<Name>();
-			}
-		}
-		template <typename Name>
-		static constexpr bool exist() {
-			if constexpr(std::is_same_v<Name,typename FirstLabel::name>) {
-				return true;
-			} else {
-				return LabelsList<Labels...>::template exist<Name>();
+		template <typename FirstLabel,typename ...Labels>
+		struct LabelsList<FirstLabel,Labels...> {
+			template <typename Name>
+			static constexpr size_t find(){
+				if constexpr (std::is_same_v<Name,typename FirstLabel::name>) {
+					return FirstLabel::offset;
+				} else {
+					static_assert(sizeof ...(Labels)!=0,"Not found label");
+					return LabelsList<Labels...>::template find<Name>();
+				}
 			}
-		}
-		template <typename Name,size_t offset>
-		struct add_s {
-			static_assert(!exist<Name>(),"Already added label");
-			using result = LabelsList<FirstLabel,Labels...,Label<Name,offset> >;
-		};
-		template <typename Name,size_t offset>
-		using add = typename add_s<Name,offset>::result;
-	};
-
-
-	template <typename ...Instructions>
-	struct InstructionsList;
-
-	template <>
-	struct InstructionsList<> {
-		static constexpr size_t length = 0;
-		explicit constexpr InstructionsList() {}
-		template <typename Instruction>
-		constexpr InstructionsList<Instruction> add( Instruction&& instr ) const {
-			return InstructionsList<Instruction>(std::move(instr),*this);
-		}
-	};
-
-
-	template <typename FirstInstruction,typename ...Instructions>
-	struct InstructionsList<FirstInstruction,Instructions...> {
-		static constexpr size_t length = 1 + InstructionsList<Instructions...>::length;
-		FirstInstruction head;
-		InstructionsList<Instructions...> tail;
-		explicit constexpr InstructionsList(FirstInstruction&& inst,const InstructionsList<Instructions...>& tail) : head(std::move(inst)),tail(tail) {}
-		template <typename Instruction>
-		constexpr InstructionsList<Instruction,FirstInstruction,Instructions...> add( Instruction&& instr) const {
-			return InstructionsList<Instruction,FirstInstruction,Instructions...>(std::move(instr),*this);
-		}
-		template <size_t I,typename ProgramBuilder>
-		constexpr Instruction encode_i(const ProgramBuilder& builder) const {
-			if constexpr (I == length-1) {
-				return head.encode(builder);
-			} else {
-				return tail.template encode_i<I>(builder);
+			template <typename Name>
+			static constexpr bool exist() {
+				if constexpr(std::is_same_v<Name,typename FirstLabel::name>) {
+					return true;
+				} else {
+					return LabelsList<Labels...>::template exist<Name>();
+				}
 			}
-		}
+			template <typename Name,size_t offset>
+			struct add_s {
+				static_assert(!exist<Name>(),"Already added label");
+				using result = LabelsList<FirstLabel,Labels...,Label<Name,offset> >;
+			};
+			template <typename Name,size_t offset>
+			using add = typename add_s<Name,offset>::result;
+		};
+
 
-		template <typename ProgramBuilder,std::size_t... I>
-		constexpr std::array<Instruction,length> build_i(const ProgramBuilder& builder,std::index_sequence<I...>) const {
-			return {{ encode_i<I>(builder)..., }};
+		template <typename ...Instructions>
+		struct InstructionsList;
+
+		template <>
+		struct InstructionsList<> {
+			static constexpr size_t length = 0;
+			explicit constexpr InstructionsList() {}
+			template <typename Instruction>
+			struct add_s {
+				using result = InstructionsList<Instruction>;
+			};
+			template <typename Instruction>
+			using add = typename add_s<Instruction>::result;
 		};
-		template <typename ProgramBuilder>
-		constexpr std::array<Instruction,length> build(const ProgramBuilder& builder) const {
-			using indexes = std::make_index_sequence<length>;
-			return build_i(builder,indexes{});
+
+
+		template <typename FirstInstruction,typename ...Instructions>
+		struct InstructionsList<FirstInstruction,Instructions...> {
+			static constexpr size_t length = 1 + InstructionsList<Instructions...>::length;
+			using head = FirstInstruction ;
+			using tail = InstructionsList<Instructions...>;
+			
+			template <typename Instruction>
+			struct add_s {
+				using result = InstructionsList<Instruction,FirstInstruction,Instructions...>;
+			};
+			template <typename Instruction>
+			using add = typename add_s<Instruction>::result;
+
+			template <size_t I,typename ProgramBuilder>
+			static constexpr Instruction encode_i(const ProgramBuilder& builder)  {
+				if constexpr (I == length-1) {
+					return head::encode(builder);
+				} else {
+					return tail::template encode_i<I>(builder);
+				}
+			}
+
+			template <typename ProgramBuilder,std::size_t... I>
+			static constexpr std::array<Instruction,length> build_i(const ProgramBuilder& builder,std::index_sequence<I...>)  {
+				return {{ encode_i<I>(builder)..., }};
+			};
+			template <typename ProgramBuilder>
+			static constexpr std::array<Instruction,length> build(const ProgramBuilder& builder) {
+				using indexes = std::make_index_sequence<length>;
+				return build_i(builder,indexes{});
+			};
 		};
-	};
 
 
-	template <size_t Length,typename Labels>
-	struct ProgramCode  {
-		static constexpr const size_t length = Length;
-		const uint16_t wrap_target;
-		const uint16_t wrap;
-		constexpr ProgramCode( std::array<Instruction,Length>&& code,uint16_t wrap_target,uint16_t wrap) : wrap_target(wrap_target),wrap(wrap),code(std::move(code)) {
+		template <size_t Length,typename Labels>
+		struct ProgramCode  {
+			static constexpr const size_t length = Length;
+			const uint16_t wrap_target;
+			const uint16_t wrap;
+			constexpr ProgramCode( std::array<Instruction,Length>&& code,uint16_t wrap_target,uint16_t wrap) : wrap_target(wrap_target),wrap(wrap),code(std::move(code)) {
 
-		}
-		const std::array<Instruction,Length> code;
-		template <typename Label>
-		static constexpr size_t getOffset() {
-			return Labels::template find<Label>();
-		}
-	};
-
-
-	template <uint32_t sideset_count_t = 0,bool sideset_is_opt_t = true, uint16_t delay_max_t = 31, uint16_t sideset_max_t = 0>
-	struct ProgramSettings {
-		static constexpr uint32_t sideset_count = sideset_count_t;
-		static constexpr bool sideset_is_opt = sideset_is_opt_t;
-		static constexpr uint16_t delay_max = delay_max_t;
-		static constexpr uint16_t sideset_max = sideset_max_t;
-	};
-	template <size_t count>
-	struct ProgramSettingsSideset {
-		static_assert(count <= 5,"maximum number of side set bits is 5");
-		using result = ProgramSettings<count,false,(1u << (5 - count)) - 1,(1u << count) - 1>;
-	};
-	template <size_t count>
-	struct ProgramSettingsOptSideset {
-		static_assert(count <= 4,"maximum number of side set bits is 4");
-		using result = ProgramSettings<count+1,true,(1u << (5 - (count+1))) - 1,(1u << count) - 1>;
-	};
-
-	struct WrapSettings {
-		OptionalValue wrap_target;
-		OptionalValue wrap_instr;
-	};
-
-	template <typename SettingsConfig, typename Labels,typename Instructions>
-	struct ProgramBuilder {
-		using labels = Labels;
-		using Settings = SettingsConfig;
-		Instructions instructions;
-		WrapSettings wrap_settings;
-
-		explicit constexpr ProgramBuilder() {}
-		explicit constexpr ProgramBuilder(Instructions && instructions,const WrapSettings& wrap_settings) : instructions(std::move(instructions)), wrap_settings(wrap_settings) {}
-		explicit constexpr ProgramBuilder(const Instructions & instructions,const WrapSettings& wrap_settings) : instructions(instructions), wrap_settings(wrap_settings) {}
+			}
+			const std::array<Instruction,Length> code;
+			template <typename Label>
+			static constexpr size_t getOffset() {
+				return Labels::template find<Label>();
+			}
+		};
 
+
+		template <uint32_t sideset_count_t = 0,bool sideset_is_opt_t = true, uint16_t delay_max_t = 31, uint16_t sideset_max_t = 0>
+		struct ProgramSettings {
+			static constexpr uint32_t sideset_count = sideset_count_t;
+			static constexpr bool sideset_is_opt = sideset_is_opt_t;
+			static constexpr uint16_t delay_max = delay_max_t;
+			static constexpr uint16_t sideset_max = sideset_max_t;
+		};
 		template <size_t count>
-		constexpr auto sideset() const {
-			return ProgramBuilder<typename ProgramSettingsSideset<count>::result,Labels,Instructions>(instructions,wrap_settings);
-		}
+		struct ProgramSettingsSideset {
+			static_assert(count <= 5,"maximum number of side set bits is 5");
+			using result = ProgramSettings<count,false,(1u << (5 - count)) - 1,(1u << count) - 1>;
+		};
 		template <size_t count>
-		constexpr auto sideset_opt() const {
-			return ProgramBuilder<typename ProgramSettingsOptSideset<count>::result,Labels,Instructions>(instructions,wrap_settings);
-		}
+		struct ProgramSettingsOptSideset {
+			static_assert(count <= 4,"maximum number of side set bits is 4");
+			using result = ProgramSettings<count+1,true,(1u << (5 - (count+1))) - 1,(1u << count) - 1>;
+		};
 
-		template <typename SideDelayConfig>
-		static constexpr uint16_t encodeSideDelay() {
-			auto res = SideDelayConfig::delay_value;
-			static_assert(SideDelayConfig::delay_value <= Settings::delay_max,"delay too long");
+		template <OptionalValue target = OptionalValue{},OptionalValue instr = OptionalValue{}>
+		struct WrapSettings {
+			static constexpr OptionalValue wrap_target = target;
+			static constexpr OptionalValue wrap_instr = instr;
+		};
 
-			if constexpr (SideDelayConfig::side_value_present) {
-				static_assert(SideDelayConfig::side_value<=Settings::sideset_max, "side value overflow");
-				res |= (SideDelayConfig::side_value << (5-Settings::sideset_count));
-				if constexpr (Settings::sideset_is_opt) {
-					res |= 1 << 4;
+		template <typename SettingsConfig, typename Labels,typename Instructions,typename WrapSettingsT>
+		struct ProgramBuilder {
+			using labels = Labels;
+			using settings = SettingsConfig;
+			using instructions = Instructions;
+			using wrap_settings = WrapSettingsT;
+
+			explicit constexpr ProgramBuilder() {}
+			
+			template <size_t count>
+			static constexpr auto sideset = ProgramBuilder<typename ProgramSettingsSideset<count>::result,labels,instructions,wrap_settings>();
+
+			template <size_t count>
+			static constexpr auto sideset_opt = ProgramBuilder<typename ProgramSettingsOptSideset<count>::result,labels,instructions,wrap_settings>();
+
+			template <typename SideDelayConfig>
+			static constexpr uint16_t encodeSideDelay() {
+				auto res = SideDelayConfig::delay_value;
+				static_assert(SideDelayConfig::delay_value <= settings::delay_max,"delay too long");
+
+				if constexpr (SideDelayConfig::side_value_present) {
+					static_assert(SideDelayConfig::side_value<=settings::sideset_max, "side value overflow");
+					res |= (SideDelayConfig::side_value << (5-settings::sideset_count));
+					if constexpr (settings::sideset_is_opt) {
+						res |= 1 << 4;
+					}
+				} else {
+					static_assert(settings::sideset_is_opt, "sideset is not optional");
 				}
-			} else {
-				static_assert(Settings::sideset_is_opt, "sideset is not optional");
+				//static_assert(side < (1<<sideset_count),"side bits overflow");
+				return res;
 			}
-			//static_assert(side < (1<<sideset_count),"side bits overflow");
-			return res;
-		}
-		template <typename Label>
-		static constexpr size_t getOffset() {
-			return Labels::template find<Label>();
-		}
-		constexpr ProgramBuilder& wrap() {
-			wrap_settings.wrap_instr.is_set = true;
-			//static_assert(Instructions::length>0 && ".wrap cannot be placed before the first program instruction");
-			wrap_settings.wrap_instr.value = Instructions::length-1;
-			return *this;
-		}
-		constexpr ProgramBuilder& wrapTarget() {
-			//static_assert(!settings.wrap_target.is_set && ".wrap_target only once");
-			wrap_settings.wrap_target.value = Instructions::length;
-			wrap_settings.wrap_target.is_set = true;
-			return *this;
-		}
-		template <typename LabelName>
-		constexpr auto label(const LabelName& = LabelName{}) const {
-			return ProgramBuilder<Settings,typename Labels::template add<LabelName,Instructions::length>,Instructions>(instructions,wrap_settings);
-		}
-		template <typename Instr>
-		constexpr auto instr( Instr&& instr ) const {
-			auto added_instructions = instructions.add(std::move(instr));
-			using AddedInstructions = decltype(added_instructions);
-			return ProgramBuilder<Settings,Labels,AddedInstructions>(std::move(added_instructions),wrap_settings);
-		}
-		constexpr ProgramCode<Instructions::length,Labels> end() const {
-			return ProgramCode<Instructions::length,Labels>(instructions.build(*this),
-				wrap_settings.wrap_target.is_set?wrap_settings.wrap_target.value:0,
-				wrap_settings.wrap_instr.is_set?wrap_settings.wrap_instr.value:(Instructions::length-1));
-		}
-	};
+			template <typename Label>
+			static constexpr size_t getOffset() {
+				return Labels::template find<Label>();
+			}
+
+			template <typename dummy=void>
+			static constexpr auto wrap = ProgramBuilder<settings,labels,instructions,WrapSettings<wrap_settings::wrap_target,{ instructions::length-1, true }>>();
 
+			template <typename dummy=void>
+			static constexpr auto wrapTarget = ProgramBuilder<settings,labels,instructions,WrapSettings<{ instructions::length, true },wrap_settings::wrap_instr>>();
+			
+			template <typename LabelName>
+			static constexpr auto label = ProgramBuilder<settings,typename Labels::template add<LabelName,instructions::length>,instructions,wrap_settings>();
+
+			template <typename Instr>
+			static  constexpr auto instr( const Instr& )  {
+				using AddedInstructions = typename instructions::add<Instr>;
+				return ProgramBuilder<settings,labels,AddedInstructions,wrap_settings>();
+			}
+			static constexpr ProgramCode<Instructions::length,Labels> end()  {
+				ProgramBuilder pb;
+				return ProgramCode<instructions::length,Labels>(instructions::build(pb),
+					wrap_settings::wrap_target.is_set?wrap_settings::wrap_target.value:0,
+					wrap_settings::wrap_instr.is_set?wrap_settings::wrap_instr.value:(Instructions::length-1));
+			}
+		};
+
+
+		using EmptyProgram = ProgramBuilder<ProgramSettings<>,LabelsList<>,InstructionsList<>,WrapSettings<>>;
+		static inline constexpr EmptyProgram  ProgramBegin() {
+			return EmptyProgram();
+		};
+	}
+
+	// public
+	static constexpr auto Jmp = implementation::Jmp();
+	template <int polarity>
+	static constexpr auto Wait = implementation::Wait<polarity>();
+	static constexpr auto In = implementation::In();
+	static constexpr auto Out = implementation::Out();
+	static constexpr auto Push = implementation::Push();
+	static constexpr auto Pull = implementation::Pull();
+	static constexpr auto Mov = implementation::Mov();
+	static constexpr auto Irq = implementation::Irq();
+	static constexpr auto Set = implementation::Set();
+	static constexpr auto Nop = implementation::Mov().y.y;
+
+	// checks
+	// Jmp
+	static_assert(implementation::check(Jmp,				0x0000),"jmp");
+	static_assert(implementation::check(Jmp.not_x,			0x0020),"jmp !x");
+	static_assert(implementation::check(Jmp.x_dec,			0x0040),"jmp x--");
+	static_assert(implementation::check(Jmp.not_y,			0x0060),"jmp !y");
+	static_assert(implementation::check(Jmp.y_dec,			0x0080),"jmp y--");
+	static_assert(implementation::check(Jmp.x_ne_y, 		0x00a0),"jmp x!=y");
+	static_assert(implementation::check(Jmp.pin,			0x00c0),"jmp pin");
+	static_assert(implementation::check(Jmp.not_osre,		0x00e0),"jmp !osre");
+	// Wait
+	static_assert(implementation::check(Wait<0>.gpio<3>,	0x2003),"wait 0 gpio 3");
+	static_assert(implementation::check(Wait<1>.gpio<3>,	0x2083),"wait 1 gpio 3");
+	static_assert(implementation::check(Wait<0>.pin<3>,		0x2023),"wait 0 pin 3");
+	static_assert(implementation::check(Wait<1>.pin<3>,		0x20a3),"wait 1 pin 3");
+	static_assert(implementation::check(Wait<0>.irq<3>,		0x2043),"wait 0 irq 3");
+	static_assert(implementation::check(Wait<1>.irq<3>,		0x20c3),"wait 1 irq 3");
+	// In
+	static_assert(implementation::check(In.pins<3>,			0x4003),"in pins, 3");
+	static_assert(implementation::check(In.x<3>,			0x4023),"in x, 3");
+	static_assert(implementation::check(In.y<3>,			0x4043),"in y, 3");
+	static_assert(implementation::check(In.null<3>,			0x4063),"in null, 3");
+	static_assert(implementation::check(In.isr<3>,			0x40c3),"in isr, 3");
+	static_assert(implementation::check(In.osr<3>,			0x40e3),"in osr, 3");
+	// Out
+	static_assert(implementation::check(Out.pins<3>,		0x6003),"out pins, 3");
+	static_assert(implementation::check(Out.x<3>,			0x6023),"out x, 3");
+	static_assert(implementation::check(Out.y<3>,			0x6043),"out y, 3");
+	static_assert(implementation::check(Out.null<3>,		0x6063),"out null, 3");
+	static_assert(implementation::check(Out.pindirs<3>,		0x6083),"out pindirs, 3");
+	static_assert(implementation::check(Out.pc<3>,			0x60a3),"out pc, 3");
+	static_assert(implementation::check(Out.isr<3>,			0x60c3),"out isr, 3");
+	static_assert(implementation::check(Out.exec<3>,		0x60e3),"out exec, 3");
+	// Push
+	static_assert(implementation::check(Push,				0x8020),"'push'");
+	static_assert(implementation::check(Push.block,			0x8020),"'push block'");
+	static_assert(implementation::check(Push.noblock,		0x8000),"'push noblock'");
+	static_assert(implementation::check(Push.iffull,		0x8060),"'push iffull'");
+	static_assert(implementation::check(Push.iffull.block,	0x8060),"'push iffull block'");
+	static_assert(implementation::check(Push.iffull.noblock,0x8040),"'push iffull noblock'");
+	// Pull
+	static_assert(implementation::check(Pull,				0x80a0),"'pull'");
+	static_assert(implementation::check(Pull.block,			0x80a0),"'pull block'");
+	static_assert(implementation::check(Pull.noblock,		0x8080),"'pull noblock'");
+	static_assert(implementation::check(Pull.ifempty,		0x80e0),"'pull ifempty'");
+	static_assert(implementation::check(Pull.ifempty.block,	0x80e0),"'pull ifempty block'");
+	static_assert(implementation::check(Pull.ifempty.noblock,0x80c0),"'pull ifempty noblock'");
+	// Mov check only all encodings, not all variants
+	static_assert(implementation::check(Mov.pins.pins,		0xa000),"mov pins,pins");
+	static_assert(implementation::check(Mov.pins.invert.pins,0xa008),"mov pins,~pins");
+	static_assert(implementation::check(Mov.pins.reverse.pins,0xa010),"mov pins,::pins");
+	static_assert(implementation::check(Mov.x.pins,			0xa020),"mov x,pins");
+	static_assert(implementation::check(Mov.x.invert.pins,	0xa028),"mov x,~pins");
+	static_assert(implementation::check(Mov.x.reverse.pins,	0xa030),"mov x,::pins");
+	static_assert(implementation::check(Mov.y.pins,			0xa040),"mov y,pins");
+	static_assert(implementation::check(Mov.y.invert.pins,	0xa048),"mov y,~pins");
+	static_assert(implementation::check(Mov.y.reverse.pins,	0xa050),"mov y,::pins");
+	static_assert(implementation::check(Mov.exec.pins,		0xa080),"mov exec,pins");
+	static_assert(implementation::check(Mov.exec.invert.pins,0xa088),"mov exec,~pins");
+	static_assert(implementation::check(Mov.exec.reverse.pins,0xa090),"mov exec,::pins");
+	static_assert(implementation::check(Mov.pc.pins,		0xa0a0),"mov pc,pins");
+	static_assert(implementation::check(Mov.pc.invert.pins,	0xa0a8),"mov pc,~pins");
+	static_assert(implementation::check(Mov.pc.reverse.pins,0xa0b0),"mov pc,::pins");
+	static_assert(implementation::check(Mov.isr.pins,		0xa0c0),"mov isr,pins");
+	static_assert(implementation::check(Mov.isr.invert.pins,0xa0c8),"mov isr,~pins");
+	static_assert(implementation::check(Mov.isr.reverse.pins,0xa0d0),"mov isr,::pins");
+	static_assert(implementation::check(Mov.osr.pins,		0xa0e0),"mov osr,pins");
+	static_assert(implementation::check(Mov.osr.invert.pins,0xa0e8),"mov osr,~pins");
+	static_assert(implementation::check(Mov.osr.reverse.pins,0xa0f0),"mov osr,::pins");
+
+	static_assert(implementation::check(Mov.pins.x,			0xa001),"mov pins,x");
+	static_assert(implementation::check(Mov.pins.invert.x,	0xa009),"mov pins,~x");
+	static_assert(implementation::check(Mov.pins.reverse.x,	0xa011),"mov pins,::x");
+	static_assert(implementation::check(Mov.pins.y,			0xa002),"mov pins,y");
+	static_assert(implementation::check(Mov.pins.invert.y,	0xa00a),"mov pins,~y");
+	static_assert(implementation::check(Mov.pins.reverse.y,	0xa012),"mov pins,::y");
+	static_assert(implementation::check(Mov.pins.null,		0xa003),"mov pins,null");
+	static_assert(implementation::check(Mov.pins.invert.null,	0xa00b),"mov pins,~null");
+	static_assert(implementation::check(Mov.pins.reverse.null,	0xa013),"mov pins,::null");
+	static_assert(implementation::check(Mov.pins.status,		0xa005),"mov pins,status");
+	static_assert(implementation::check(Mov.pins.invert.status,	0xa00d),"mov pins,~status");
+	static_assert(implementation::check(Mov.pins.reverse.status,0xa015),"mov pins,::status");
+	static_assert(implementation::check(Mov.pins.isr,			0xa006),"mov pins,isr");
+	static_assert(implementation::check(Mov.pins.invert.isr,	0xa00e),"mov pins,~isr");
+	static_assert(implementation::check(Mov.pins.reverse.isr,	0xa016),"mov pins,::isr");
+	static_assert(implementation::check(Mov.pins.osr,			0xa007),"mov pins,osr");
+	static_assert(implementation::check(Mov.pins.invert.osr,	0xa00f),"mov pins,~osr");
+	static_assert(implementation::check(Mov.pins.reverse.osr,	0xa017),"mov pins,::osr");
+	// Irq
+	//static_assert(implementation::check(Irq<3>,				0xc003),"irq 3"); // not supported, use 'irq set/irq nowait' equivalent
+	static_assert(implementation::check(Irq.set<3>,			0xc003),"irq set 3");
+	static_assert(implementation::check(Irq.nowait<3>,		0xc003),"irq nowait 3");
+	static_assert(implementation::check(Irq.wait<3>,		0xc023),"irq wait 3");
+	static_assert(implementation::check(Irq.clear<3>,		0xc043),"irq clear 3");
+	// Set
+	static_assert(implementation::check(Set.pins<3>,		0xe003),"set pins,3");
+	static_assert(implementation::check(Set.x<3>,			0xe023),"set x,3");
+	static_assert(implementation::check(Set.y<3>,			0xe043),"set y,3");
+	static_assert(implementation::check(Set.pindirs<3>,		0xe083),"set pindirs,3");
 
-	using EmptyProgram = ProgramBuilder<ProgramSettings<>,LabelsList<>,InstructionsList<>>;
-	static inline constexpr EmptyProgram  ProgramBegin() {
-		return EmptyProgram();
-	};
 }
diff --git a/src/modm/platform/pio/rp/pio_program.hpp b/src/modm/platform/pio/rp/pio_program.hpp
index b1396da9a4..7390c030f6 100644
--- a/src/modm/platform/pio/rp/pio_program.hpp
+++ b/src/modm/platform/pio/rp/pio_program.hpp
@@ -17,12 +17,12 @@ namespace modm::platform
 {
 
 	struct PIOProgram {
-		const pio::Instruction* instructions;
+		const pio::implementation::Instruction* instructions;
 		const uint8_t length;
 		int8_t origin;
-		constexpr PIOProgram(const pio::Instruction* code,uint8_t length,int8_t origin) : instructions(code),length(length),origin(origin) {}
-		static constexpr pio::EmptyProgram begin() {
-			return pio::ProgramBegin();
+		constexpr PIOProgram(const pio::implementation::Instruction* code,uint8_t length,int8_t origin) : instructions(code),length(length),origin(origin) {}
+		static constexpr pio::implementation::EmptyProgram begin() {
+			return pio::implementation::ProgramBegin();
 		}
 		template <typename Program>
 		static constexpr PIOProgram get(const Program& data) {
diff --git a/src/modm/platform/pio/rp/pio_sm.hpp b/src/modm/platform/pio/rp/pio_sm.hpp
index b1ac663171..031a0916d0 100644
--- a/src/modm/platform/pio/rp/pio_sm.hpp
+++ b/src/modm/platform/pio/rp/pio_sm.hpp
@@ -14,7 +14,7 @@
 #include <modm/processing/resumable/resumable.hpp>
 #include <hardware/structs/pio.h>
 
-namespace modm::platform::pio
+namespace modm::platform::pio::implementation
 {
 
 	template <typename Pio,size_t SM>
@@ -25,7 +25,7 @@ namespace modm::platform::pio
 			return Pio::pio().sm[SM];
 		}
 		struct Encoder {
-			constexpr uint16_t encodeSideDelay(const pio::OptionalValue& /*side*/,uint16_t /*delay*/) const {
+			constexpr uint16_t encodeSideDelay(const pio::implementation::OptionalValue& /*side*/,uint16_t /*delay*/) const {
 				return 0;
 			}
 		};
@@ -34,9 +34,9 @@ namespace modm::platform::pio
 			sm().pinctrl =
                 (1u << PIO_SM0_PINCTRL_SET_COUNT_LSB) |
                 (uint32_t(Pin::pin) << PIO_SM0_PINCTRL_SET_BASE_LSB);
-            exec(pio::Set().pindirs<isOut?1:0>().encode(Encoder()));
+            exec(pio::Set.pindirs<isOut?1:0>.encode(Encoder()));
 		}
-		static inline void exec(const pio::Instruction& instr) {
+		static inline void exec(const pio::implementation::Instruction& instr) {
 			sm().instr = instr.value;
 		}
 		static constexpr uint32_t STALL_MASK = 1u << (PIO_FDEBUG_TXSTALL_LSB + SM);
@@ -216,7 +216,7 @@ namespace modm::platform::pio
 		}
 
 		static void jump(uint16_t pc) {
-			exec(pio::Jmp().encode(Encoder())|pc);
+			exec(pio::Jmp.encode(Encoder())|pc);
 		}
 
 		static inline bool txFifoFull() {
diff --git a/src/modm/platform/pio/rp/pio_sm_impl.hpp.in b/src/modm/platform/pio/rp/pio_sm_impl.hpp.in
index 05d56c9ef3..db17536c93 100644
--- a/src/modm/platform/pio/rp/pio_sm_impl.hpp.in
+++ b/src/modm/platform/pio/rp/pio_sm_impl.hpp.in
@@ -15,7 +15,7 @@
 
 template <typename Pio,size_t SM>
 modm::ResumableResult<uint32_t>
-modm::platform::pio::StateMachine<Pio, SM>::read()
+modm::platform::pio::implementation::StateMachine<Pio, SM>::read()
 {
 %% if use_fiber
     // wait data
@@ -29,7 +29,7 @@ modm::platform::pio::StateMachine<Pio, SM>::read()
 
 template <typename Pio,size_t SM>
 modm::ResumableResult<void>
-modm::platform::pio::StateMachine<Pio, SM>::write(uint32_t val)
+modm::platform::pio::implementation::StateMachine<Pio, SM>::write(uint32_t val)
 {
 %% if use_fiber
     // wait data