Make UI7::IO::CurrentViewPort a Reference (finally)

[pd-3ds]: Use new debug values
[pd-lithium]: Add functionality to DrawList::Optimize
[pd-ui7]: Add setters for Menu pos ans size

.clang-format

@@ -0,0 +1,334 @@
+---
+Language:        Cpp
+AccessModifierOffset: -1
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: true
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveShortCaseStatements:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCaseArrows: false
+  AlignCaseColons: false
+AlignConsecutiveTableGenBreakingDAGArgColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenCondOperatorColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignConsecutiveTableGenDefinitionColons:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  AlignFunctionDeclarations: false
+  AlignFunctionPointers: false
+  PadOperators:    false
+AlignEscapedNewlines: Left
+AlignOperands:   Align
+AlignTrailingComments:
+  Kind:            Always
+  OverEmptyLines:  0
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowBreakBeforeNoexceptSpecifier: Never
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseExpressionOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortCompoundRequirementOnASingleLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AllowShortNamespacesOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AttributeMacros:
+  - __capability
+  - absl_nonnull
+  - absl_nullable
+  - absl_nullability_unknown
+BinPackArguments: true
+BinPackLongBracedList: true
+BinPackParameters: BinPack
+BitFieldColonSpacing: Both
+BracedInitializerIndentWidth: -1
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterExternBlock: false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakAdjacentStringLiterals: true
+BreakAfterAttributes: Leave
+BreakAfterJavaFieldAnnotations: false
+BreakAfterReturnType: None
+BreakArrays:     true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInlineASMColon: OnlyMultiline
+BreakBeforeTemplateCloser: false
+BreakBeforeTernaryOperators: true
+BreakBinaryOperations: Never
+BreakConstructorInitializers: BeforeColon
+BreakFunctionDefinitionParameters: false
+BreakInheritanceList: BeforeColon
+BreakStringLiterals: true
+BreakTemplateDeclarations: Yes
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+EnumTrailingComma: Leave
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Regroup
+IncludeCategories:
+  - Regex:           '^<ext/.*\.h>'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*\.h>'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^<.*'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseBlocks: false
+IndentCaseLabels: true
+IndentExportBlock: true
+IndentExternBlock: AfterExternBlock
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentRequiresClause: true
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertNewlineAtEOF: false
+InsertTrailingCommas: None
+IntegerLiteralSeparator:
+  Binary:          0
+  BinaryMinDigits: 0
+  Decimal:         0
+  DecimalMinDigits: 0
+  Hex:             0
+  HexMinDigits:    0
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLines:
+  AtEndOfFile:     false
+  AtStartOfBlock:  false
+  AtStartOfFile:   true
+KeepFormFeed:    false
+LambdaBodyIndentation: Signature
+LineEnding:      DeriveLF
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MainIncludeChar: Quote
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Never
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+OneLineFormatOffRegex: ''
+PackConstructorInitializers: NextLine
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakBeforeMemberAccess: 150
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakScopeResolution: 500
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyIndentedWhitespace: 0
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+PPIndentWidth:   -1
+QualifierAlignment: Leave
+RawStringFormats:
+  - Language:        Cpp
+    Delimiters:
+      - cc
+      - CC
+      - cpp
+      - Cpp
+      - CPP
+      - 'c++'
+      - 'C++'
+    CanonicalDelimiter: ''
+    BasedOnStyle:    google
+  - Language:        TextProto
+    Delimiters:
+      - pb
+      - PB
+      - proto
+      - PROTO
+    EnclosingFunctions:
+      - EqualsProto
+      - EquivToProto
+      - PARSE_PARTIAL_TEXT_PROTO
+      - PARSE_TEST_PROTO
+      - PARSE_TEXT_PROTO
+      - ParseTextOrDie
+      - ParseTextProtoOrDie
+      - ParseTestProto
+      - ParsePartialTestProto
+    CanonicalDelimiter: pb
+    BasedOnStyle:    google
+ReferenceAlignment: Pointer
+ReflowComments:  Always
+RemoveBracesLLVM: false
+RemoveEmptyLinesInUnwrappedLines: false
+RemoveParentheses: Leave
+RemoveSemicolon: false
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: OuterScope
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SkipMacroDefinitionBody: false
+SortIncludes:
+  Enabled:         true
+  IgnoreCase:      false
+SortJavaStaticImport: Before
+SortUsingDeclarations: LexicographicNumeric
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterOperatorKeyword: false
+SpaceAfterTemplateKeyword: true
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeJsonColon: false
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterNot:        false
+  AfterOverloadedOperator: false
+  AfterPlacementOperator: true
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceBeforeSquareBrackets: false
+SpaceInEmptyBlock: false
+SpacesBeforeTrailingComments: 2
+SpacesInAngles:  Never
+SpacesInContainerLiterals: true
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParens:  Never
+SpacesInParensOptions:
+  ExceptDoubleParentheses: false
+  InCStyleCasts:   false
+  InConditionalStatements: false
+  InEmptyParentheses: false
+  Other:           false
+SpacesInSquareBrackets: false
+Standard:        Auto
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TableGenBreakInsideDAGArg: DontBreak
+TabWidth:        8
+UseTab:          Never
+VerilogBreakBetweenInstancePorts: true
+WhitespaceSensitiveMacros:
+  - BOOST_PP_STRINGIZE
+  - CF_SWIFT_NAME
+  - NS_SWIFT_NAME
+  - PP_STRINGIZE
+  - STRINGIZE
+WrapNamespaceBodyWithEmptyLines: Leave
+...
+

.gitattributes

@@ -0,0 +1,2 @@
+include/pd/external/* linguist-vendored
+backends/desktop/glad/* linguist-vendored

.gitignore

@@ -1,3 +1,3 @@
-build/
+build*/
 .cache
 .vscode

CMakeLists.txt

@@ -1,5 +1,7 @@
 cmake_minimum_required(VERSION 3.22)
 
+include(GNUInstallDirs)
+
 # Set Project
 project(palladium LANGUAGES C CXX VERSION 0.6.0)
 
@@ -8,29 +10,154 @@ set(PD_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
 include(cmake/palladium.cmake)
 
 option(PD_BUILD_TESTS "Sets if TestApp and TestBench get build" OFF)
-option(PD_BUILD_SHARED "Build Shared Libraries" OFF)
+option(PD_BUILD_SHARED "Build Shared Library" OFF)
 option(PD_BUILD_TOOLS "Build Palladium Tools" OFF)
+option(PD_BUILD_DESKTOP "Build Desktop Backend" OFF)
+option(PD_BUILD_3DS "Build 3ds Backend" OFF)
+option(PD_BUNDLE_GLFW "Bundle GLFW in install" OFF)
 
 if(${PD_BUILD_TOOLS})
     add_subdirectory(tools)
 endif()
 
-## Include Library Source
+# # Include Library Source
+set(PD_SOURCES
 
-add_subdirectory(pd/drivers)
+    # Core
-add_subdirectory(pd/core)
+    source/core/bit_util.cpp
-add_subdirectory(pd/image)
+    source/core/color.cpp
-add_subdirectory(pd/external)
+    source/core/io.cpp
-add_subdirectory(pd/lithium)
+    source/core/mat.cpp
-add_subdirectory(pd/ui7)
+    source/core/strings.cpp
+    source/core/timer.cpp
+    source/core/timetrace.cpp
 
-add_library(palladium INTERFACE)
+    # Drivers
-target_link_libraries(palladium INTERFACE
+    source/drivers/context.cpp
-    pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+    source/drivers/gfx.cpp
+    source/drivers/hid.cpp
+    source/drivers/os.cpp
+
+    # External
+    source/external/stb.cpp
+
+    # Image
+    source/image/image.cpp
+    source/image/img_blur.cpp
+    source/image/img_convert.cpp
+
+    # Lithium
+    source/lithium/command.cpp
+    source/lithium/drawlist.cpp
+    source/lithium/font.cpp
+    source/lithium/fonts.cpp
+    source/lithium/renderer.cpp
+
+    # UI7
+    source/ui7/container/button.cpp
+    source/ui7/container/checkbox.cpp
+    source/ui7/container/coloredit.cpp
+    source/ui7/container/container.cpp
+    source/ui7/container/dragdata.cpp
+    source/ui7/container/dynobj.cpp
+    source/ui7/container/image.cpp
+    source/ui7/container/label.cpp
+    source/ui7/container/slider.cpp
+    source/ui7/io.cpp
+    source/ui7/layout.cpp
+    source/ui7/menu.cpp
+    source/ui7/theme.cpp
+    source/ui7/ui7.cpp
 )
 
-add_dependencies(palladium
+if(${PD_BUILD_SHARED})
-    pd-drivers pd-core pd-image pd-external pd-lithium pd-ui7 #pd-net
+    add_library(palladium SHARED ${PD_SOURCES})
+    target_compile_definitions(palladium PRIVATE -DPD_BUILD_SHARED)
+else()
+    add_library(palladium STATIC ${PD_SOURCES})
+    target_compile_definitions(palladium PUBLIC -DPD_BUILD_STATIC)
+endif()
+
+add_library(palladium::palladium ALIAS palladium)
+
+target_include_directories(palladium
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
 )
 
-install(DIRECTORY include DESTINATION ".")
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Nintendo3DS")
+    target_compile_options(palladium PRIVATE
+        $<$<COMPILE_LANGUAGE:C>:-Wall>
+        $<$<COMPILE_LANGUAGE:C>:-Wno-psabi>
+        $<$<COMPILE_LANGUAGE:CXX>:-fno-exceptions>
+    )
+endif()
+
+target_compile_options(palladium PRIVATE
+    $<$<CONFIG:Debug>:-O0 -g>
+    $<$<CONFIG:Release>:-O3>
+)
+
+if(PD_BUILD_DESKTOP AND NOT PD_BUILD_3DS)
+    add_subdirectory(backends/desktop)
+endif()
+if(PD_BUILD_3DS AND NOT PD_BUILD_DESKTOP)
+    add_subdirectory(backends/3ds)
+endif()
+
+install(TARGETS palladium
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+install(DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+install(EXPORT palladiumTargets
+    FILE palladiumTargets.cmake
+    NAMESPACE palladium::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+include(CMakePackageConfigHelpers)
+configure_package_config_file(
+    cmake/palladiumConfig.cmake.in
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+install(FILES
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/palladiumConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/palladium
+)
+
+
+find_program(CLANG_FORMAT clang-format)
+
+file(GLOB_RECURSE PD_FMTFILES CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/pd/core/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/pd/drivers/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/pd/image/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/pd/lithium/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/include/pd/ui7/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/desktop/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/3ds/include/*.hpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/desktop/include/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/backends/3ds/include/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test/source*.cpp
+)
+
+add_custom_target(pd-clang-format
+    COMMAND ${CLANG_FORMAT} --style=file -i ${PD_FMTFILES}
+    COMMENT "Formatting Project Sources"
+)

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 - 2025 René Amthor tobid7
+Copyright (c) 2024 - 2026 René Amthor tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

backends/3ds/CMakeLists.txt

@@ -8,6 +8,30 @@ set(SRC
     source/pd-3ds.cpp
 )
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/libpicasso)
-pd_add_lib(pd-3ds SRC_FILES ${SRC})
+add_library(pd-3ds STATIC ${SRC})
-target_include_directories(pd-3ds PUBLIC include)
+target_include_directories(pd-3ds PUBLIC
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
 target_link_libraries(pd-3ds PUBLIC m palladium ctru citro3d pica::pica)
+add_library(palladium::pd-3ds ALIAS pd-3ds)
+install(TARGETS pd-3ds
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(TARGETS pica
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)

backends/3ds/include/pd-3ds.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -28,6 +27,6 @@ SOFTWARE.
 #include <pd-3ds/bknd-hid.hpp>
 
 namespace PD {
-PD::Li::Font::Ref LoadSystemFont();
+PD::Li::Font::Ref LoadSystemFont(Context& ctx);
 void Init(void* data = nullptr);
 }  // namespace PD

backends/3ds/include/pd-3ds/bknd-gfx.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -33,7 +32,7 @@ SOFTWARE.
 namespace PD {
 class GfxC3D : public GfxDriver {
  public:
-  GfxC3D() : GfxDriver("Citro3D") {}
+  GfxC3D(PDDriverData data = nullptr) : GfxDriver("Citro3D") {}
   ~GfxC3D() = default;
 
   PD_SHARED(GfxC3D);
@@ -42,13 +41,13 @@ class GfxC3D : public GfxDriver {
   void Deinit() override;
   void NewFrame() override;
   void BindTex(PD::Li::TexAddress addr) override;
-  void RenderDrawData(
+  void RenderDrawData(const PD::Li::CmdPool& Commands) override;
-      const std::vector<PD::Li::Command::Ref>& Commands) override;
   PD::Li::Texture::Ref LoadTex(
       const std::vector<PD::u8>& pixels, int w, int h,
       PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
       PD::Li::Texture::Filter filter =
           PD::Li::Texture::Filter::LINEAR) override;
+  void DestroyTex(PD::Li::Texture::Ref tex) override;
 
   std::vector<Li::Vertex, LinearAllocator<Li::Vertex>> VertexBuffer;
   std::vector<u16, LinearAllocator<u16>> IndexBuffer;
@@ -57,5 +56,9 @@ class GfxC3D : public GfxDriver {
   shaderProgram_s Shader;
   C3D_AttrInfo ShaderInfo;
   std::vector<u8> pRawShader;
+  u32 pCountVertices = 0;
+  u32 pCountIndices = 0;
+  u32 pCountDrawCalls = 0;
+  u32 pDrawCommands = 0;
 };
 }  // namespace PD

backends/3ds/include/pd-3ds/bknd-hid.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -29,7 +28,7 @@ SOFTWARE.
 namespace PD {
 class Hid3DS : public HidDriver {
  public:
-  Hid3DS();
+  Hid3DS(PDDriverData data = nullptr);
   ~Hid3DS() = default;
 
   PD_SHARED(Hid3DS);

backends/3ds/include/pd-3ds/linearAllocator.hpp

@@ -1,5 +1,28 @@
 #pragma once
 
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
 #include <3ds.h>
 
 #include <pd/core/common.hpp>
@@ -19,7 +42,7 @@ class LinearAllocator {
 
   T* allocate(std::size_t n) {
     if (n > max_size()) {
-      throw std::runtime_error("[PD] LinearAllocator: Bad alloc!");
+      PD::Throw("[PD] LinearAllocator: Bad alloc!");
     }
     return static_cast<T*>(linearAlloc(n * sizeof(T)));
   }

backends/3ds/source/bknd-gfx.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -95,6 +94,11 @@ void FragCfg(GPU_TEXCOLOR clr) {
       C3D_TexEnvFunc(env, C3D_RGB, GPU_REPLACE);
       C3D_TexEnvFunc(env, C3D_Alpha, GPU_MODULATE);
       break;
+    case GPU_RGB565:
+      C3D_TexEnvSrc(env, C3D_Alpha, GPU_TEXTURE0);
+      C3D_TexEnvFunc(env, C3D_RGB, GPU_MODULATE);
+      C3D_TexEnvFunc(env, C3D_Alpha, GPU_REPLACE);
+      break;
 
     default:
       C3D_TexEnvSrc(env, C3D_Both, GPU_TEXTURE0);
@@ -134,15 +138,22 @@ void GfxC3D::NewFrame() {
   CurrentVertex = 0;
   FrameCounter++;
   /** Probably completly incorrect but just do it like that */
-  VertexCounter = CurrentVertex;
+  VertexCounter = pCountVertices;
-  IndexCounter = CurrentIndex;
+  IndexCounter = pCountIndices;
+  DrawCalls = pCountDrawCalls;
+  DrawCommands = pDrawCommands;
+  pCountDrawCalls = 0;
+  pCountIndices = 0;
+  pCountVertices = 0;
+  pDrawCommands = 0;
 }
 
 void GfxC3D::BindTex(PD::Li::TexAddress addr) {
   C3D_TexBind(0, reinterpret_cast<C3D_Tex*>(addr));
 }
 
-void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+void GfxC3D::RenderDrawData(const PD::Li::CmdPool& Commands) {
+  pDrawCommands += Commands.Size();
   shaderProgramUse(&Shader);
   C3D_SetAttrInfo(&ShaderInfo);
   C3D_Mtx proj;
@@ -151,20 +162,22 @@ void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
   // Mat4 proj = Mat4::Ortho(0.f, ViewPort.x, ViewPort.y, 0.f, 1.f, -1.f);
   // C3D_FVUnifMtx4x4(GPU_VERTEX_SHADER, pLocProjection, (C3D_Mtx*)&proj);
   size_t index = 0;
-  while (index < Commands.size()) {
+  while (index < Commands.Size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+    PD::Li::TexAddress Tex = Commands.GetCmd(index)->Tex;
     if (!Tex) {
       index++;
       continue;
     }
-    bool ScissorEnabled = Commands[index]->ScissorOn;
+    bool ScissorEnabled = Commands.GetCmd(index)->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;
     size_t StartIndex = CurrentIndex;
 
-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorEnabled &&
+           Commands.GetCmd(index)->ScissorOn == ScissorEnabled &&
-           Commands[index]->ScissorRect == ScissorRect) {
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
+      auto c = Commands.GetCmd(index);
+      pCountIndices += c->IndexBuffer.size();
+      pCountVertices += c->VertexBuffer.size();
       for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
         IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
       }
@@ -176,20 +189,23 @@ void GfxC3D::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
     if (ScissorEnabled) {
       // Figure out this setup was pain
       C3D_SetScissor(GPU_SCISSOR_NORMAL,
-                     ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                     std::clamp(ViewPort.y - (ScissorRect.y + ScissorRect.w), 0,
-                     ViewPort.x - (ScissorRect.x + ScissorRect.z),
+                                ViewPort.y),
+                     std::clamp(ViewPort.x - (ScissorRect.x + ScissorRect.z), 0,
+                                ViewPort.x),
                      ViewPort.y - ScissorRect.y, ViewPort.x - ScissorRect.x);
     } else {
       C3D_SetScissor(GPU_SCISSOR_DISABLE, 0, 0, 0, 0);
     }
-    FragCfg(((C3D_Tex*)Tex->Address)->fmt);
+    FragCfg(((C3D_Tex*)Tex)->fmt);
-    BindTex(Tex->Address);
+    BindTex(Tex);
     auto bufInfo = C3D_GetBufInfo();
     BufInfo_Init(bufInfo);
     BufInfo_Add(bufInfo, VertexBuffer.data(), sizeof(Li::Vertex), 3, 0x210);
 
     C3D_DrawElements(GPU_TRIANGLES, CurrentIndex - StartIndex,
                      C3D_UNSIGNED_SHORT, IndexBuffer.data() + StartIndex);
+    pCountDrawCalls++;
   }
   C3D_DepthTest(true, GPU_GREATER, GPU_WRITE_ALL);
 }
@@ -255,4 +271,11 @@ PD::Li::Texture::Ref GfxC3D::LoadTex(const std::vector<PD::u8>& pixels, int w,
             << std::endl;
   return res;
 }
+
+void GfxC3D::DestroyTex(PD::Li::Texture::Ref tex) {
+  C3D_Tex* t = reinterpret_cast<C3D_Tex*>(tex->Address);
+  C3D_TexDelete(t);
+  delete t;
+  tex->Address = 0;
+}
 }  // namespace PD

backends/3ds/source/bknd-hid.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +26,7 @@ SOFTWARE.
 #include <pd-3ds/bknd-hid.hpp>
 
 namespace PD {
-Hid3DS::Hid3DS() : HidDriver("Hid3DS") {
+Hid3DS::Hid3DS(PDDriverData data) : HidDriver("Hid3DS") {
   this->Flags |= Flags_HasTouch;
   this->Flags |= FLags_HasGamepad;
   pBinds[KEY_A] = A;
@@ -65,7 +64,7 @@ void Hid3DS::Update() {
   u32 kd = hidKeysDown();
   u32 kh = hidKeysHeld();
   u32 ku = hidKeysUp();
-  for (auto &b : pBinds) {
+  for (auto& b : pBinds) {
     if (b.first & kd) {
       KeyEvents[0][Event_Down] |= b.second;
     }

backends/3ds/source/pd-3ds.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -28,9 +27,9 @@ SOFTWARE.
 #include <pd-3ds.hpp>
 
 namespace PD {
-PD::Li::Font::Ref LoadSystemFont() {
+PD::Li::Font::Ref LoadSystemFont(Context& ctx) {
-  TT::Scope st("LI_SystemFont");  // Trace loading time
+  TT::Scope st(*ctx.Os(), "LI_SystemFont");  // Trace loading time
-  Li::Font::Ref ret = Li::Font::New();
+  Li::Font::Ref ret = Li::Font::New(ctx);
   fontEnsureMapped();  // Call this to be sure the font is mapped
   // Get some const references for system font loading
   const auto fnt = fontGetSystemFont();
@@ -125,8 +124,8 @@ PD::Li::Font::Ref LoadSystemFont() {
 void Init(void* data) {
   // Dekstop Init Stage
   // First use default OS Driver
-  PD::OS::Init();
+  // PD::OS::Init();
-  PD::Gfx::Init(PD::GfxC3D::New());
+  // PD::Gfx::Init(PD::GfxC3D::New());
-  PD::Hid::Init(PD::Hid3DS::New());
+  // PD::Hid::Init(PD::Hid3DS::New());
 }
 }  // namespace PD

backends/desktop/CMakeLists.txt

@@ -2,6 +2,14 @@ cmake_minimum_required(VERSION 3.22)
 
 project(pd-desktop LANGUAGES CXX VERSION 0.5.0)
 
+set(PD_GL_VERSION 21 CACHE STRING "OpenGL Version (2.1 -> 21, 3.3 -> 33)")
+
+if(APPLE)
+    set(PD_GL_VERSION 33 CACHE STRING "33" FORCE)
+endif()
+
+message("Using OpenGL: " ${PD_GL_VERSION})
+
 add_subdirectory(glad)
 add_subdirectory(glfw)
 
@@ -11,6 +19,44 @@ set(SRC
     source/pd-desktop.cpp
 )
 
-pd_add_lib(pd-desktop SRC_FILES ${SRC})
+add_library(pd-desktop STATIC ${SRC})
-target_include_directories(pd-desktop PUBLIC include)
+target_include_directories(pd-desktop
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
 target_link_libraries(pd-desktop PUBLIC palladium glad glfw)
+
+target_compile_definitions(pd-desktop
+    PRIVATE PD_OPENGL=${PD_GL_VERSION}
+)
+
+add_library(palladium::pd-desktop ALIAS pd-desktop)
+
+install(TARGETS pd-desktop
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(DIRECTORY include/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(TARGETS glad
+    EXPORT palladiumTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+if(PD_BUNDLE_GLFW)
+    install(TARGETS glfw
+        EXPORT palladiumTargets
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    )
+endif()

backends/desktop/glad/CMakeLists.txt

@@ -1,4 +1,8 @@
 cmake_minimum_required(VERSION 3.22)
 
 add_library(glad source/glad.c)
-target_include_directories(glad PUBLIC include)
+target_include_directories(glad
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)

backends/desktop/include/pd-desktop.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

backends/desktop/include/pd-desktop/bknd-gfx.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -35,7 +34,7 @@ SOFTWARE.
 namespace PD {
 class GfxGL2 : public GfxDriver {
  public:
-  GfxGL2() : GfxDriver("OpenGL2") {}
+  GfxGL2(PDDriverData data = nullptr) : GfxDriver("OpenGL2") {}
   ~GfxGL2() = default;
 
   PD_SHARED(GfxGL2);
@@ -44,8 +43,7 @@ class GfxGL2 : public GfxDriver {
   void Deinit() override;
   void NewFrame() override;
   void BindTex(PD::Li::TexAddress addr) override;
-  void RenderDrawData(
+  void RenderDrawData(const Li::CmdPool& Commands) override;
-      const std::vector<PD::Li::Command::Ref>& Commands) override;
   PD::Li::Texture::Ref LoadTex(
       const std::vector<PD::u8>& pixels, int w, int h,
       PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
@@ -57,6 +55,35 @@ class GfxGL2 : public GfxDriver {
   GLuint Shader;
   GLuint pLocProjection;
   GLuint pLocTex;
-  GLuint VBO, IBO;
+  GLuint pLocAlfa;
+  GLuint VBO, IBO, VAO;  // vao is only used in > 3.3
+};
+
+class GfxGL3 : public GfxDriver2 {
+ public:
+  GfxGL3() : GfxDriver2("OpenGL3") {}
+  ~GfxGL3() = default;
+
+  PD_SHARED(GfxGL3);
+
+  void Init() override;
+  void Deinit() override;
+  // void NewFrame() override;
+  void TexBind(PD::Li::TexAddress addr) override;
+  void Draw(const Li::CmdPool& pool) override;
+  PD::Li::TexAddress TexLoad(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter =
+          PD::Li::Texture::Filter::LINEAR) override;
+  void TexDelete(PD::Li::TexAddress tex) override;
+
+  std::vector<Li::Vertex> VertexBuffer;
+  std::vector<PD::u16> IndexBuffer;
+  GLuint Shader;
+  GLuint pLocProjection;
+  GLuint pLocTex;
+  GLuint pLocAlfa;
+  GLuint VBO, IBO, VAO;  // vao is only used in > 3.3
 };
 }  // namespace PD

backends/desktop/include/pd-desktop/bknd-hid.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -31,7 +30,7 @@ SOFTWARE.
 namespace PD {
 class HidGLFW : public HidDriver {
  public:
-  HidGLFW(GLFWwindow* win);
+  HidGLFW(PDDriverData data);
   ~HidGLFW() = default;
 
   PD_SHARED(HidGLFW);
@@ -45,7 +44,7 @@ class HidGLFW : public HidDriver {
         pTimings.erase(k);
         return false;
       }
-      return (PD::OS::GetTime() - pTimings[k]) > 50;
+      return 0;  //(PD::OS::GetTime() - pTimings[k]) > 50;
     }
     if (!IsEvent(Event_Held, k)) {
       if (pTimings.count(k)) {
@@ -54,7 +53,7 @@ class HidGLFW : public HidDriver {
       }
     }
     if (IsEvent(Event_Held, k)) {
-      pTimings[k] = PD::OS::GetTime();
+      pTimings[k] = 0;  // PD::OS::GetTime();
       return true;
     }
     return false;
@@ -64,6 +63,7 @@ class HidGLFW : public HidDriver {
   GLFWwindow* Window;
   int PrevState;
   std::unordered_map<int, int> PrevStates;
+  static GLFWcharfun pOldTextCB;
   static std::string* pText;
   bool pInTextMode = false;
   PD::u64 pLastUpdate = 0;

backends/desktop/source/bknd-gfx.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,6 +24,7 @@ SOFTWARE.
 #include <pd-desktop/bknd-gfx.hpp>
 
 namespace PD {
+#if PD_OPENGL >= 21 && PD_OPENGL < 33
 const char* vertex_shader = R"(
   #version 120
   
@@ -53,12 +53,62 @@ const char* frag_shader = R"(
   varying vec4 oColor;
   
   uniform sampler2D tex;
+  uniform bool alfa;
       
   void main() {
-      vec4 tc = texture2D(tex, oUV);
+    vec4 tc = texture2D(tex, oUV);
-      gl_FragColor = tc*oColor;
+    if (alfa) {
+      gl_FragColor = vec4(oColor.rgb, tc.a * oColor.a);
+    } else {
+      gl_FragColor = tc * oColor;
+    }
   }
   )";
+#elif PD_OPENGL >= 33
+const char* vertex_shader = R"(
+  #version 330 core
+  
+  layout(location = 0) in vec2 pos;
+  layout(location = 1) in vec2 uv;
+  layout(location = 2) in vec4 color;
+  
+  out vec2 oUV;
+  out vec4 oColor;
+  
+  // Probably forgot about this matrix and
+  // searched hours for why the rendering isn't working :/
+  uniform mat4 projection;
+  
+  void main() {
+      gl_Position = projection*vec4(pos, 0.0, 1.0);
+      oUV = uv;
+      oColor = color;
+  }
+  )";
+
+const char* frag_shader = R"(
+  #version 330 core
+      
+  in vec2 oUV;
+  in vec4 oColor;
+  
+  uniform sampler2D tex;
+  uniform bool alfa;
+
+  out vec4 FragColor;
+      
+  void main() {
+    vec4 tc = texture(tex, oUV);
+    if (alfa) {
+      FragColor = vec4(oColor.rgb, tc.a * oColor.a);
+    } else {
+      FragColor = tc * oColor;
+    }
+  }
+  )";
+#else
+// Need to show error
+#endif
 
 GLuint compileShader(const std::string& source, GLenum type) {
   GLuint shader = glCreateShader(type);
@@ -128,25 +178,47 @@ void GfxGL2::Init() {
   Shader = createShaderProgram(vertex_shader, frag_shader);
   glUseProgram(Shader);
 
+#if PD_OPENGL >= 33
+  glGenVertexArrays(1, &VAO);
+  glBindVertexArray(VAO);
+#endif
+
   glGenBuffers(1, &VBO);
   glBindBuffer(GL_ARRAY_BUFFER, VBO);
 
-  // Attribs Setup
+#if PD_OPENGL < 33
-  SetupShaderAttribs(Shader);
+  SetupShaderAttribs(Shader);  // GL 2.1
-
+#else
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Pos));
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, UV));
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Color));
+#endif
   glGenBuffers(1, &IBO);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
 
   pLocTex = glGetUniformLocation(Shader, "tex");
+  pLocAlfa = glGetUniformLocation(Shader, "alfa");
   pLocProjection = glGetUniformLocation(Shader, "projection");
 
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#if PD_OPENGL >= 33
+  glBindVertexArray(0);
+#endif
 }
 
 void GfxGL2::Deinit() {
   glDeleteBuffers(1, &VBO);
   glDeleteBuffers(1, &IBO);
+#if PD_OPENGL >= 33
+  glDeleteBuffers(1, &VAO);
+#endif
 }
 
 void GfxGL2::NewFrame() {
@@ -172,24 +244,27 @@ void GfxGL2::BindTex(PD::Li::TexAddress addr) {
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
   glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
 }
 
-void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
+void GfxGL2::RenderDrawData(const Li::CmdPool& Commands) {
   size_t index = 0;
-  while (index < Commands.size()) {
+  while (index < Commands.Size()) {
-    PD::Li::Texture::Ref Tex = Commands[index]->Tex;
+    PD::Li::TexAddress Tex = Commands.GetCmd(index)->Tex;
     if (!Tex) {
       index++;
       continue;
     }
     size_t StartIndex = CurrentIndex;
-    bool ScissorOn = Commands[index]->ScissorOn;
+    bool ScissorOn = Commands.GetCmd(index)->ScissorOn;
-    ivec4 ScissorRect = Commands[index]->ScissorRect;
+    ivec4 ScissorRect = Commands.GetCmd(index)->ScissorRect;
 
-    while (index < Commands.size() && Commands[index]->Tex == Tex &&
+    while (index < Commands.Size() && Commands.GetCmd(index)->Tex == Tex &&
-           Commands[index]->ScissorOn == ScissorOn &&
+           Commands.GetCmd(index)->ScissorOn == ScissorOn &&
-           Commands[index]->ScissorRect == ScissorRect) {
+           Commands.GetCmd(index)->ScissorRect == ScissorRect) {
-      auto c = Commands[index].get();
+      auto c = Commands.GetCmd(index);
       for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
         IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
       }
@@ -205,13 +280,21 @@ void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
     } else {
       glDisable(GL_SCISSOR_TEST);
     }
-    BindTex(Tex->Address);
+    BindTex(Tex);
+
+#if PD_OPENGL >= 33
+    glBindVertexArray(VAO);
+#endif
+
     glBindBuffer(GL_ARRAY_BUFFER, VBO);
     glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
                  &VertexBuffer[0], GL_DYNAMIC_DRAW);
+
+#if PD_OPENGL < 33
     // For some reason we need to set these every frame for every buffer
     // Found that out when creating My 3d Engine
     SetupShaderAttribs(Shader);
+#endif
 
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
     glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
@@ -223,6 +306,10 @@ void GfxGL2::RenderDrawData(const std::vector<PD::Li::Command::Ref>& Commands) {
     glBindBuffer(GL_ARRAY_BUFFER, 0);
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
     BindTex(0);
+#if PD_OPENGL >= 33
+    glBindVertexArray(0);
+#endif
+    glDisable(GL_SCISSOR_TEST);
   }
 }
 
@@ -251,6 +338,165 @@ PD::Li::Texture::Ref GfxGL2::LoadTex(const std::vector<PD::u8>& pixels, int w,
   }
   glBindTexture(GL_TEXTURE_2D, 0);
   auto res = PD::Li::Texture::New(texID, PD::ivec2(w, h));
+  std::cout << std::format("Texture loaded: {} {}", texID, PD::ivec2(w, h))
+            << std::endl;
   return res;
 }
+
+void GfxGL3::Init() {
+  VertexBuffer.resize(4 * 8192);
+  IndexBuffer.resize(6 * 8192);
+  Shader = createShaderProgram(vertex_shader, frag_shader);
+  glUseProgram(Shader);
+
+#if PD_OPENGL >= 33
+  glGenVertexArrays(1, &VAO);
+  glBindVertexArray(VAO);
+#endif
+
+  glGenBuffers(1, &VBO);
+  glBindBuffer(GL_ARRAY_BUFFER, VBO);
+
+#if PD_OPENGL < 33
+  SetupShaderAttribs(Shader);  // GL 2.1
+#else
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Pos));
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, UV));
+  glEnableVertexAttribArray(2);
+  glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(PD::Li::Vertex),
+                        (void*)offsetof(PD::Li::Vertex, Color));
+#endif
+  glGenBuffers(1, &IBO);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+
+  pLocTex = glGetUniformLocation(Shader, "tex");
+  pLocAlfa = glGetUniformLocation(Shader, "alfa");
+  pLocProjection = glGetUniformLocation(Shader, "projection");
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+#if PD_OPENGL >= 33
+  glBindVertexArray(0);
+#endif
+}
+
+void GfxGL3::Deinit() {
+  glDeleteBuffers(1, &VBO);
+  glDeleteBuffers(1, &IBO);
+#if PD_OPENGL >= 33
+  glDeleteBuffers(1, &VAO);
+#endif
+}
+
+// void NewFrame()  {
+//}
+
+void GfxGL3::TexBind(PD::Li::TexAddress addr) {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, (GLuint)addr);
+  glUniform1i(pLocTex, 0);
+  GLint fmt = 0;
+  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &fmt);
+  glUniform1i(pLocAlfa, fmt == GL_ALPHA);
+}
+
+void GfxGL3::Draw(const Li::CmdPool& pool) {
+  size_t index = 0;
+  while (index < pool.Size()) {
+    PD::Li::TexAddress Tex = pool.GetCmd(index)->Tex;
+    if (Tex == 0) {
+      index++;
+      continue;
+    }
+    size_t StartIndex = CurrentIndex;
+    bool ScissorOn = pool.GetCmd(index)->ScissorOn;
+    ivec4 ScissorRect = pool.GetCmd(index)->ScissorRect;
+
+    while (index < pool.Size() && pool.GetCmd(index)->Tex == Tex &&
+           pool.GetCmd(index)->ScissorOn == ScissorOn &&
+           pool.GetCmd(index)->ScissorRect == ScissorRect) {
+      auto c = pool.GetCmd(index);
+      for (size_t i = 0; i < c->IndexBuffer.size(); i++) {
+        IndexBuffer[CurrentIndex++] = CurrentVertex + c->IndexBuffer.at(i);
+      }
+      for (size_t i = 0; i < c->VertexBuffer.size(); i++) {
+        VertexBuffer[CurrentVertex++] = c->VertexBuffer.at(i);
+      }
+      index++;
+    }
+    if (ScissorOn) {
+      glScissor(ScissorRect.x, ViewPort.y - (ScissorRect.y + ScissorRect.w),
+                ScissorRect.z, ScissorRect.w);
+      glEnable(GL_SCISSOR_TEST);
+    } else {
+      glDisable(GL_SCISSOR_TEST);
+    }
+    TexBind(Tex);
+
+#if PD_OPENGL >= 33
+    glBindVertexArray(VAO);
+#endif
+
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    glBufferData(GL_ARRAY_BUFFER, CurrentVertex * sizeof(PD::Li::Vertex),
+                 &VertexBuffer[0], GL_DYNAMIC_DRAW);
+
+#if PD_OPENGL < 33
+    // For some reason we need to set these every frame for every buffer
+    // Found that out when creating My 3d Engine
+    SetupShaderAttribs(Shader);
+#endif
+
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, IBO);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, CurrentIndex * sizeof(PD::u16),
+                 &IndexBuffer[0], GL_DYNAMIC_DRAW);
+
+    glDrawElements(GL_TRIANGLES, CurrentIndex - StartIndex, GL_UNSIGNED_SHORT,
+                   (void*)(StartIndex * sizeof(PD::u16)));
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    TexBind(0);
+#if PD_OPENGL >= 33
+    glBindVertexArray(0);
+#endif
+  }
+}
+
+PD::Li::TexAddress GfxGL3::TexLoad(const std::vector<PD::u8>& pixels, int w,
+                                   int h, PD::Li::Texture::Type type,
+                                   PD::Li::Texture::Filter filter) {
+  GLuint texID;
+  glGenTextures(1, &texID);
+  glBindTexture(GL_TEXTURE_2D, texID);
+
+  // Set base format (Always using RGBA as base)
+  GLenum fmt = GL_RGBA;
+  if (type == PD::Li::Texture::Type::RGB24) {
+    fmt = GL_RGB;
+  } else if (type == PD::Li::Texture::Type::A8) {
+    fmt = GL_ALPHA;
+  }
+  glTexImage2D(GL_TEXTURE_2D, 0, fmt, w, h, 0, fmt, GL_UNSIGNED_BYTE,
+               pixels.data());
+  if (filter == PD::Li::Texture::Filter::LINEAR) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  } else if (filter == PD::Li::Texture::Filter::NEAREST) {
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  }
+  glBindTexture(GL_TEXTURE_2D, 0);
+  return texID;
+}
+
+void GfxGL3::TexDelete(PD::Li::TexAddress tex) {
+  GLuint tex_ = tex;
+  glDeleteTextures(1, &tex_);
+}
+
 }  // namespace PD

backends/desktop/source/bknd-hid.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,19 +23,32 @@ SOFTWARE.
 
 #include <pd-desktop/bknd-hid.hpp>
 namespace PD {
-std::string* HidGLFW::pText;
+std::string* HidGLFW::pText = nullptr;
+GLFWcharfun HidGLFW::pOldTextCB = nullptr;
 // Default Call back (If no Text input is requsted)
-void NullTextCB(GLFWwindow* win, unsigned int c) {}
+void NullTextCB(GLFWwindow* win, unsigned int c) {
+  // Chain
+  if (HidGLFW::pOldTextCB) {
+    HidGLFW::pOldTextCB(win, c);
+  }
+}
 // Text callback if requested
 void TextCB(GLFWwindow* win, unsigned int c) {
+  // Chain
+  if (HidGLFW::pOldTextCB) {
+    HidGLFW::pOldTextCB(win, c);
+  }
   if (!HidGLFW::pText) {
     return;
   }
   *HidGLFW::pText += (char)c;
 }
-HidGLFW::HidGLFW(GLFWwindow* win) : HidDriver("HidGLFW") {
+HidGLFW::HidGLFW(PDDriverData data) : HidDriver("HidGLFW") {
-  Window = win;
+  if (!data) {
-  glfwSetCharCallback(Window, NullTextCB);
+    std::cout << "[HidGLFW] Error: Data pointer was null" << std::endl;
+  }
+  Window = reinterpret_cast<GLFWwindow*>(data);
+  HidGLFW::pOldTextCB = glfwSetCharCallback(Window, NullTextCB);
   Flags |= Flags_HasKeyboard;
   Flags |= Flags_HasMouse;
   pBinds[GLFW_MOUSE_BUTTON_LEFT] = Touch;
@@ -139,10 +151,10 @@ void HidGLFW::Update() {
   glfwGetCursorPos(Window, &x, &y);
   pMouse[1] = pMouse[0];  // Cycle pMouse pos
   pMouse[0] = fvec2(x, y);
-  if (pInTextMode && (PD::OS::GetTime() - pLastUpdate) > 50) {
+  /*if (pInTextMode && (PD::OS::GetTime() - pLastUpdate) > 50) {
-    pLastUpdate = PD::OS::GetTime();
+      pLastUpdate = PD::OS::GetTime();
-    HandleTextOps();
+      HandleTextOps();
-  }
+    }*/
 }
 
 void HidGLFW::GetInputStr(std::string& str) {

backends/desktop/source/pd-desktop.cpp

@@ -1,7 +1,6 @@
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +26,7 @@ SOFTWARE.
 
 namespace PD {
 void Init(void* data) {
-  if (!data) {
+  /*if (!data) {
     std::cout << "[PD-DRIVERS] Error: pd-desktop requires GLFWwindow* "
                  "reference as data "
                  "input!"
@@ -38,6 +37,6 @@ void Init(void* data) {
   // First use default OS Driver
   PD::OS::Init();
   PD::Gfx::Init(PD::GfxGL2::New());
-  PD::Hid::Init(PD::HidGLFW::New(reinterpret_cast<GLFWwindow*>(data)));
+  PD::Hid::Init(PD::HidGLFW::New(reinterpret_cast<GLFWwindow*>(data)));*/
 }
 }  // namespace PD

cmake/palladiumConfig.cmake.in

@@ -0,0 +1,6 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/palladiumTargets.cmake")
+if(NOT TARGET palladium::pd-desktop AND PALLADIUM_FIND_DESKTOP)
+    find_dependency(palladium::pd-desktop OPTIONAL)
+endif()

include/palladium

@@ -1,5 +1,28 @@
 #pragma once
 
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
 #include <pd/core/core.hpp>
 #include <pd/drivers/drivers.hpp>
 #include <pd/external/json.hpp>

include/pd/core/bit_util.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -36,12 +35,12 @@ namespace BitUtil {
  * @param v 32 bit unsigned int
  * @return true if its a single bit number
  */
-PD_CORE_API bool IsSingleBit(u32 v);
+PD_API bool IsSingleBit(u32 v);
 /**
  * Get the Next Power of two Number
  * @param v Current Number
  * @return Next Number thats a Pow of 2
  */
-PD_CORE_API u32 GetPow2(u32 v);
+PD_API u32 GetPow2(u32 v);
 }  // namespace BitUtil
 }  // namespace PD

include/pd/core/color.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -27,7 +27,7 @@ SOFTWARE.
 #include <pd/core/strings.hpp>
 
 namespace PD {
-class PD_CORE_API Color {
+class PD_API Color {
  public:
   /**
    * Default Constructor (all variables are set to 0)
@@ -78,7 +78,7 @@ class PD_CORE_API Color {
    */
   constexpr Color& Hex(const std::string_view& hex) {
     if (!(hex.length() == 7 || hex.length() == 9)) {
-      throw "[PD] Color: hex string is not rgb or rgba!";
+      PD::Throw("[PD] Color: hex string is not rgb or rgba!");
     }
     r = PD::Strings::HexChar2Int(hex[1]) * 16 +
         PD::Strings::HexChar2Int(hex[2]);

include/pd/core/common.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -42,7 +42,7 @@ SOFTWARE.
 #include <vector>
 
 /** Dynamic Lib loading */
-#include <pd/core/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 /** Memory Management */
 
@@ -53,6 +53,16 @@ SOFTWARE.
     return std::make_shared<x>(std::forward<Args>(args)...); \
   }
 
+#define PD_RAW(x)                           \
+  using Ref = x*;                           \
+  template <typename... Args>               \
+  static Ref New(Args&&... args) {          \
+    x* v = new x;                           \
+    new (v) x(std::forward<Args>(args)...); \
+    return v;                               \
+  }                                         \
+  static void Delete(Ref ref) { delete ref; }
+
 #define PD_UNIQUE(x)                                         \
   using Ref = std::unique_ptr<x>;                            \
   template <typename... Args>                                \
@@ -64,7 +74,12 @@ SOFTWARE.
 
 namespace PD {
 [[noreturn]] inline void Throw(const std::string& str) {
-  throw std::runtime_error("[PD] " + str);
+#ifdef _EXCEPTIONS
+  throw std::runtime_error("PD Error " + str);
+#else
+  std::cout << "PD Error " << str << std::endl;
+  std::abort();
+#endif
 }
 /** Types */
 using u8 = unsigned char;

include/pd/core/core.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,8 +26,10 @@ SOFTWARE.
 #include <pd/core/bit_util.hpp>
 #include <pd/core/color.hpp>
 #include <pd/core/fnv.hpp>
+#include <pd/core/hashid.hpp>
 #include <pd/core/io.hpp>
 #include <pd/core/mat.hpp>
+#include <pd/core/pool.hpp>
 #include <pd/core/strings.hpp>
 #include <pd/core/timer.hpp>
 #include <pd/core/timetrace.hpp>

include/pd/core/fnv.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -50,4 +50,21 @@ constexpr u64 FNV1A64(std::string_view str) {
   }
   return ret;
 }
+
+namespace Detail {
+template <typename T>
+struct FNV1A {};
+
+template <>
+struct FNV1A<u32> {
+  static constexpr u32 Hash(std::string_view str) { return FNV1A32(str); }
+  static constexpr u32 Hash(const std::string& str) { return FNV1A32(str); }
+};
+
+template <>
+struct FNV1A<u64> {
+  static constexpr u64 Hash(std::string_view str) { return FNV1A64(str); }
+  static constexpr u64 Hash(const std::string& str) { return FNV1A64(str); }
+};
+}  // namespace Detail
 }  // namespace PD

include/pd/core/fquat.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/core/hashid.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <pd/core/fnv.hpp>
+#include <pd/core/strings.hpp>
+
+namespace PD {
+template <typename T>
+class HashID {
+ public:
+  using __Type = T;
+
+  constexpr HashID() {};
+  constexpr HashID(T id) { pID = id; }
+  HashID(const std::string& name) {
+    pID = Detail::FNV1A<T>::Hash(name);
+#ifdef PD_HASHID_KEEP_STR
+    pName = name;
+#endif
+  }
+  constexpr HashID(const char* name) {
+    pID = Detail::FNV1A<T>::Hash(std::string_view(name));
+#ifdef PD_HASHID_KEEP_STR
+    pName = name;
+#endif
+  }
+  ~HashID() {}
+
+  constexpr T Get() { return pID; }
+
+  std::string GetName() const {
+#ifdef PD_HASHID_KEEP_STR
+    return pName;
+#else
+    return std::format("hash({:#08x})", pID);
+#endif
+  }
+
+  operator T() const { return pID; }
+  // operator std::string() const { return GetName(); }
+
+ private:
+  T pID;
+#ifdef PD_HASHID_KEEP_STR
+  str pName;
+#endif
+};
+
+using HashID32 = HashID<u32>;
+using HashID64 = HashID<u64>;
+}  // namespace PD

include/pd/core/io.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -35,28 +35,28 @@ namespace IO {
  * @param path Path to the File
  * @return 8Bit FileBuffer
  */
-PD_CORE_API std::vector<u8> LoadFile2Mem(const std::string& path);
+PD_API std::vector<u8> LoadFile2Mem(const std::string& path);
 /**
  * Load a File into a std::string
  * @param path Path to the File
  * @return std::string file content
  */
-PD_CORE_API std::string LoadFile2Str(const std::string& path);
+PD_API std::string LoadFile2Str(const std::string& path);
 /**
  * Hash a 8Bit Memory Buffer
  * @param data 8Bit input Buffer
  * @return 32Bit Hash
  */
-PD_CORE_API u32 HashMemory(const std::vector<u8>& data);
+PD_API u32 HashMemory(const std::vector<u8>& data);
 /**
  * Function to decrompress RLE buffer
  * @param data Data buffer to decompress
  */
-PD_CORE_API void DecompressRLE(std::vector<u8>& data);
+PD_API void DecompressRLE(std::vector<u8>& data);
 /**
  * Function to compress data with RLE Algorithm
  * @param data Data buf
  */
-PD_CORE_API void CompressRLE(std::vector<u8>& data);
+PD_API void CompressRLE(std::vector<u8>& data);
 }  // namespace IO
 }  // namespace PD

include/pd/core/mat.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -41,7 +40,7 @@ constexpr float Radians(float v) { return v * (Numbers::Tau / 360.0f); }
  * @note That this is not a full Matrix Library
  */
 
-struct PD_CORE_API Mat4 {
+struct PD_API Mat4 {
   std::array<float, 16> m;
   constexpr Mat4() : m{} {}
   constexpr static Mat4 Diagonal(float x, float y, float z, float w) {

include/pd/core/pd_p_api.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-/** Generated with ppam */
-
-#ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __declspec(dllexport)
-#else
-#define PD_CORE_API __declspec(dllimport)
-#endif
-#elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __attribute__((visibility("default")))
-#else
-#define PD_CORE_API
-#endif
-#elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_CORE_BUILD_SHARED
-#define PD_CORE_API __attribute__((visibility("default")))
-#else
-#define PD_CORE_API
-#endif
-#elif defined(__3DS__)  // 3ds Specific
-// Only Static supported
-#define PD_CORE_API
-#else
-#define PD_CORE_API
-#endif

include/pd/core/pool.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <pd/core/common.hpp>
+
+namespace PD {
+template <typename T, typename Alloc = std::allocator<T>>
+class Pool {
+ public:
+  Pool() = default;
+  ~Pool() = default;
+
+  static Pool* Create(size_t size) { return new Pool(size); }
+
+  void Init(size_t size) {
+    pPos = 0;
+    pCap = size;
+    pPool.resize(size);
+  }
+
+  Pool(const Pool&) = delete;
+  Pool(Pool&&) = delete;
+  Pool& operator=(const Pool&) = delete;
+  Pool& operator=(Pool&&) = delete;
+
+  T* Allocate(size_t num = 1) {
+    if (CheckLimits(num)) return nullptr;
+    T* ret = &pPool[pPos];
+    pPos += num;
+    return ret;
+  }
+
+  bool CheckLimits(size_t num) {
+    if ((pPos + num) >= pCap) {
+      throw std::runtime_error(
+          std::format("[PD::Pool]: Trying to allocate {} elements but this is "
+                      "going out of range ({}/{})",
+                      num, pPos + num, pCap));
+      return true;
+    }
+    return false;
+  }
+
+  void Reset() { pPos = 0; }
+
+ private:
+  Pool(size_t size) : pCap(size), pPos(0) { pPool.resize(size); }
+  size_t pCap = 0;
+  size_t pPos = 0;
+  std::vector<T, Alloc> pPool;
+};
+}  // namespace PD

include/pd/core/strings.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -43,47 +43,47 @@ constexpr int HexChar2Int(char c) {
  * @param exts List of Extensions to check for
  * @return true if one of the extensions is found in the String
  */
-PD_CORE_API bool StringEndsWith(const std::string& str,
+PD_API bool StringEndsWith(const std::string& str,
-                                const std::vector<std::string>& exts);
+                           const std::vector<std::string>& exts);
 /**
  * Function to Create a wstring of a string
  * @param s Input String to Convert
  * @return Result wstring
  * @note Returns Empty if it has an error
  */
-PD_CORE_API std::wstring MakeWstring(const std::string& s);
+PD_API std::wstring MakeWstring(const std::string& s);
 /**
  * Generate a Formatted String by an Nanoseconds Input
  * @param nanos Nanoseconds Input
  * @return Result String
  */
-PD_CORE_API const std::string FormatNanos(unsigned long long nanos);
+PD_API const std::string FormatNanos(unsigned long long nanos);
 /**
  * Generate a Formatted String by an Milliseconds Input
  * @param millis Milliseconds Input
  * @return Result String
  */
-PD_CORE_API const std::string FormatMillis(unsigned long long millis);
+PD_API const std::string FormatMillis(unsigned long long millis);
 /**
  * Create a formatted String by an input bytes value
  * @param bytes value in bytes
  * @result Formatted String for example `2.5MB`
  */
-PD_CORE_API const std::string FormatBytes(unsigned long long bytes);
+PD_API const std::string FormatBytes(unsigned long long bytes);
 /**
  * Extract the Filename out of a Path
  * @param path Path to extract from
  * @param saperators Path Split Chars
  * @return extracted filename
  */
-PD_CORE_API const std::string GetFileName(
+PD_API const std::string GetFileName(const std::string& path,
-    const std::string& path, const std::string& saperators = "/\\");
+                                     const std::string& saperators = "/\\");
 /**
  * Remove Extension from a Path / Filename
  * @param path Input Path
  * @return Path without Extension
  */
-PD_CORE_API const std::string PathRemoveExtension(const std::string& path);
+PD_API const std::string PathRemoveExtension(const std::string& path);
 /**
  * Function to Convert a Type to a hex value
  * @tparam T Type
@@ -101,7 +101,7 @@ inline const std::string ToHex(const T& v) {
  * @param s String to hash
  * @return 32Bit Hash
  */
-PD_CORE_API u32 FastHash(const std::string& s);
+PD_API u32 FastHash(const std::string& s);
 /**
  * Function to Generate a Compiler Name and Version String
  * Based on their Macros
@@ -127,4 +127,48 @@ inline const std::string GetCompilerVersion() {
   return res.str();
 }
 }  // namespace Strings
+class U8Iterator {
+ public:
+  explicit U8Iterator(const char* s) : ptr(reinterpret_cast<const u8*>(s)) {}
+  ~U8Iterator() = default;
+
+  bool Decode32(u32& ret) {
+    if (ptr == nullptr || *ptr == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+      ptr += 1;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+      ptr += 2;
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+      ptr += 3;
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+      ptr += 4;
+    }
+    return true;
+  }
+
+  bool PeekNext32(u32& ret) {
+    // if ((ptr + 1) == 0 || *(ptr + 1) == 0) return false;
+    u8 c = *ptr;
+    if (c < 0x80) {
+      ret = c;
+    } else if ((c >> 5) == 0x6) {
+      ret = ((c & 0x1F) << 6) | (ptr[1] & 0x3F);
+    } else if ((c >> 4) == 0xE) {
+      ret = ((c & 0x0F) << 12) | ((ptr[1] & 0x3F) << 6) | (ptr[2] & 0x3F);
+    } else {
+      ret = ((c & 0x07) << 18) | ((ptr[1] & 0x3F) << 12) |
+            ((ptr[2] & 0x3F) << 6) | (ptr[3] & 0x3F);
+    }
+    return true;
+  }
+
+ private:
+  const u8* ptr = nullptr;
+};
 }  // namespace PD

include/pd/core/timer.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,16 +26,17 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+class OsDriver;
 /**
  * Timer class
  */
-class PD_CORE_API Timer {
+class PD_API Timer {
  public:
   /**
    * Constructor
    * @param auto_start [default true] sets if timer should start after creation
    */
-  Timer(bool auto_start = true);
+  Timer(OsDriver& os, bool auto_start = true);
   /**
    * Unused Deconstructor
    */
@@ -81,5 +82,7 @@ class PD_CORE_API Timer {
   u64 pNow;
   /** Is Running */
   bool pIsRunning = false;
+  /** Os Driver reference */
+  OsDriver& pOs;
 };
 }  // namespace PD

include/pd/core/timetrace.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,6 +26,7 @@ SOFTWARE.
 #include <pd/core/common.hpp>
 
 namespace PD {
+class OsDriver;
 /**
  * Class to calculate Maximum/Minimum and Average Timings
  */
@@ -102,12 +103,12 @@ class TimeStats {
    * Get Data Buffer
    * @return data bufer (not edidable)
    */
-  const std::vector<u64> &GetData() { return val; }
+  const std::vector<u64>& GetData() { return val; }
   /**
    * Access an element in the list [not edidable]
    * @return value to access
    */
-  const u64 &operator[](int i) { return val[smart_idx(i)]; }
+  const u64& operator[](int i) { return val[smart_idx(i)]; }
   /**
    * Get List Lengh
    * @return Lengh
@@ -160,7 +161,7 @@ class Res {
    * Setter for the ID (Name)
    * @param v ID of the Trace
    */
-  void SetID(const std::string &v) { id = v; }
+  void SetID(const std::string& v) { id = v; }
   /**
    * Getter for the traces ID
    * @return Trace ID
@@ -218,12 +219,12 @@ class Res {
  * Begin a Trace
  * @param id Name of the Trace
  */
-PD_CORE_API void Beg(const std::string &id);
+PD_API void Beg(OsDriver& os, const std::string& id);
 /**
  * End a Trace
  * @param id Name of the Trace
  */
-PD_CORE_API void End(const std::string &id);
+PD_API void End(OsDriver& os, const std::string& id);
 /**
  * Collect Start end end of the trace by tracking
  * when the Scope object goes out of scope
@@ -245,18 +246,20 @@ class Scope {
    * Constructor requiring a Name for the Trace
    * @param id Name of the Trace
    */
-  Scope(const std::string &id) {
+  Scope(OsDriver& os, const std::string& id) : pOs(os) {
     this->ID = id;
-    Beg(id);
+    Beg(pOs, id);
   }
   /**
    * Deconstructor getting the end time when going out of scope
    */
-  ~Scope() { End(ID); }
+  ~Scope() { End(pOs, ID); }
 
  private:
   /** Trace Name/ID */
   std::string ID;
+  /** Os Driver Reference */
+  OsDriver& pOs;
 };
 }  // namespace TT
 }  // namespace PD

include/pd/core/tween.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/core/vec.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/core/vec2.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/core/vec3.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/core/vec4.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/drivers/context.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/core/core.hpp>
+#include <pd/drivers/gfx.hpp>
+#include <pd/drivers/hid.hpp>
+#include <pd/drivers/os.hpp>
+
+namespace PD {
+class PD_API Context {
+ public:
+  Context()
+      : pOs(OsDriver::New()), pGfx(GfxDriver::New()), pHid(HidDriver::New()) {}
+  ~Context() {}
+
+  PD_RAW(Context);
+
+  static Context::Ref Create();
+
+  template <typename Driver>
+  void UseGfxDriver(PDDriverData data) {
+    static_assert(std::is_base_of<GfxDriver, Driver>::value,
+                  "Driver must extend GfxDriver");
+    pGfx.reset();
+    pGfx = Driver::New(data);
+  }
+
+  template <typename Driver>
+  void UseHidDriver(PDDriverData data) {
+    static_assert(std::is_base_of<HidDriver, Driver>::value,
+                  "Driver must extend HidDriver");
+    pHid.reset();
+    pHid = Driver::New(data);
+  }
+
+  template <typename Driver>
+  void UseOsDriver(PDDriverData data) {
+    static_assert(std::is_base_of<OsDriver, Driver>::value,
+                  "Driver must extend OsDriver");
+    pOs.reset();
+    pOs = Driver::New(data);
+  }
+
+  PD::Li::Texture::Ref GetSolidTex();
+
+  OsDriver::Ref Os() { return pOs; }
+  GfxDriver::Ref Gfx() { return pGfx; }
+  HidDriver::Ref Hid() { return pHid; }
+
+ private:
+  OsDriver::Ref pOs = nullptr;
+  GfxDriver::Ref pGfx = nullptr;
+  HidDriver::Ref pHid = nullptr;
+
+  PD::Li::Texture::Ref pSolidTex = nullptr;
+};
+}  // namespace PD

include/pd/drivers/drivers.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -23,6 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
  */
 
+#include <pd/drivers/context.hpp>
 #include <pd/drivers/gfx.hpp>
 #include <pd/drivers/hid.hpp>
 #include <pd/drivers/os.hpp>

include/pd/drivers/gfx.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,6 +24,7 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/drivers/types.hpp>
 #include <pd/lithium/command.hpp>
 #include <pd/lithium/texture.hpp>
 
@@ -34,9 +35,35 @@ enum LiBackendFlags_ {
 };
 
 namespace PD {
+// The backend api nobody asked for
+class GfxDriver2 {
+ public:
+  GfxDriver2(const std::string& name = "NullGfx") : pName(name) {};
+  ~GfxDriver2() = default;
+
+  virtual void Init() {}
+  virtual void Deinit() {}
+  virtual void Draw(const PD::Li::CmdPool& pool) {}
+  virtual void TexBind(PD::Li::TexAddress addr) {}
+  virtual PD::Li::TexAddress TexLoad(
+      const std::vector<PD::u8>& pixels, int w, int h,
+      PD::Li::Texture::Type type = PD::Li::Texture::Type::RGBA32,
+      PD::Li::Texture::Filter filter = PD::Li::Texture::Filter::LINEAR) {
+    return 0;
+  }
+  virtual void TexDelete(PD::Li::TexAddress tex) {}
+
+ protected:
+  const std::string pName;
+  LiBackendFlags pFlags = 0;
+  size_t CurrentIndex = 0;
+  size_t CurrentVertex = 0;
+  ivec2 ViewPort;
+};
 class GfxDriver {
  public:
-  GfxDriver(const std::string& name = "NullGfx") : pName(name) {};
+  GfxDriver(const std::string& name = "NullGfx") : pName(name) {}
+  GfxDriver(PDDriverData data) : pName("NullGfx") {}
   ~GfxDriver() = default;
 
   PD_SHARED(GfxDriver);
@@ -49,9 +76,10 @@ class GfxDriver {
 
   virtual void BindTex(Li::TexAddress addr) {}
 
-  virtual void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {}
+  virtual void RenderDrawData(const Li::CmdPool& Commands) {}
 
   void SetViewPort(const ivec2& vp) { ViewPort = vp; }
+  void SetViewPort(int w, int h) { ViewPort = PD::ivec2(w, h); }
 
   virtual Li::Texture::Ref LoadTex(
       const std::vector<u8>& pixels, int w, int h,
@@ -61,8 +89,12 @@ class GfxDriver {
     return nullptr;
   }
 
+  virtual void DestroyTex(PD::Li::Texture::Ref tex) {}
+
   Li::Texture::Ref GetSolidTex() { return pSolid; }
 
+  const std::string& GetName() const { return pName; }
+
   const std::string pName = "NullGfx";
   LiBackendFlags Flags = 0;
   ivec2 ViewPort;
@@ -79,37 +111,9 @@ class GfxDriver {
   u32 VertexCounter;
   // Optional Frame Counter
   u64 FrameCounter;
-};
+  // Draw calls counter
-
+  u32 DrawCalls;
-/** Static Gfx Controller */
+  // Command Counter
-class Gfx {
+  u32 DrawCommands;
- public:
-  Gfx() = default;
-  ~Gfx() = default;
-
-  static void Init(GfxDriver::Ref d);
-
-  static void Deinit() { pGfx->Deinit(); }
-  static void NewFrame() { pGfx->NewFrame(); }
-
-  static void BindTex(Li::TexAddress addr) { pGfx->BindTex(addr); }
-  static void SetViewPort(const ivec2& vp) { pGfx->SetViewPort(vp); }
-  static void SetViewPort(int w, int h) { pGfx->SetViewPort(PD::ivec2(w, h)); }
-
-  static void RenderDrawData(const std::vector<Li::Command::Ref>& Commands) {
-    pGfx->RenderDrawData(Commands);
-  }
-
-  static LiBackendFlags Flags() { return pGfx->Flags; }
-  static Li::Texture::Ref LoadTex(
-      const std::vector<u8>& pixels, int w, int h,
-      Li::Texture::Type type = Li::Texture::Type::RGBA32,
-      Li::Texture::Filter filter = Li::Texture::Filter::LINEAR) {
-    return pGfx->LoadTex(pixels, w, h, type, filter);
-  }
-
-  static Li::Texture::Ref GetSolidTex() { return pGfx->GetSolidTex(); }
-
-  static GfxDriver::Ref pGfx;
 };
 }  // namespace PD

include/pd/drivers/hid.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,6 +24,7 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/drivers/types.hpp>
 
 namespace PD {
 /** Did not found a better solution yet sadly */
@@ -82,7 +83,8 @@ constexpr static KbKey Kb_F11 = KbKey::Flag(47);
 constexpr static KbKey Kb_F12 = KbKey::Flag(48);
 constexpr static KbKey Kb_MouseLeft = KbKey::Flag(120);
 }  // namespace HidKb
-class HidDriver {
+
+class PD_API HidDriver {
  public:
   enum Flags : u32 {
     Flags_None = 0,
@@ -134,7 +136,8 @@ class HidDriver {
     Event_Up,    ///< Key released
   };
 
-  HidDriver(const std::string& name = "NullHid") : pName(name) {};
+  HidDriver(const std::string& name = "NullHid") : pName(name) {}
+  HidDriver(PDDriverData data) : pName("NullHid") {}
   virtual ~HidDriver() = default;
   PD_SHARED(HidDriver);
 
@@ -233,6 +236,8 @@ class HidDriver {
    */
   virtual void GetInputStr(std::string& str) {}
 
+  const std::string& GetName() const { return pName; }
+
   /** Data Section */
 
   /** Backend Identification Name */
@@ -255,42 +260,8 @@ class HidDriver {
   /** Keyboard Key Event Table Setup */
   std::unordered_map<Event, u128> KbKeyEvents[2];
 };
-
+namespace Hid {
-/** Static Hid Controller */
+using Event = HidDriver::Event;
-class Hid {
+using Key = HidDriver::Key;
- public:
+}  // namespace Hid
-  Hid() = default;
-  ~Hid() = default;
-
-  /** Referenec to Drivers enums */
-  using Key = HidDriver::Key;
-  using KbKey = HidKb::KbKey;
-  using Event = HidDriver::Event;
-
-  static void Init(HidDriver::Ref v = nullptr) {
-    if (v) {
-      pHid = v;
-    } else {
-      pHid = HidDriver::New();
-    }
-  }
-
-  static bool IsEvent(Event e, Key keys) { return pHid->IsEvent(e, keys); }
-  static bool IsEvent(Event e, KbKey key) { return pHid->IsEvent(e, key); }
-  static bool IsDown(Key keys) { return pHid->IsDown(keys); }
-  static bool IsUp(Key keys) { return pHid->IsUp(keys); }
-  static bool IsHeld(Key keys) { return pHid->IsHeld(keys); }
-  static fvec2 MousePos() { return pHid->MousePos(); }
-  static fvec2 MousePosLast() { return pHid->MousePosLast(); }
-  static void Clear() { pHid->Clear(); }
-  static void Lock() { pHid->Lock(); }
-  static void Lock(bool v) { pHid->Lock(v); }
-  static void Unlock() { pHid->Unlock(); }
-  static bool Locked() { return pHid->Locked(); }
-  static void Update() { pHid->Update(); }
-  static u32 GetFlags() { return pHid->Flags; }
-  static void GetStrInput(std::string& str) { pHid->GetInputStr(str); }
-
-  static HidDriver::Ref pHid;
-};
 }  // namespace PD

include/pd/drivers/os.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,13 +25,16 @@ SOFTWARE.
 
 #include <pd/core/common.hpp>
 #include <pd/core/timetrace.hpp>
+#include <pd/drivers/types.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 using TraceMap = std::map<std::string, TT::Res::Ref>;
 
-class OsDriver {
+class PD_API OsDriver {
  public:
-  OsDriver() = default;
+  OsDriver(const std::string& name = "StdPd") : pName(name) {}
+  OsDriver(PDDriverData data) : pName("StdPd") {}
   virtual ~OsDriver() = default;
   PD_SHARED(OsDriver);
 
@@ -40,32 +43,11 @@ class OsDriver {
   TraceMap& GetTraceMap();
   TT::Res::Ref& GetTraceRef(const std::string& id);
   bool TraceExist(const std::string& id);
+  const std::string& GetName() const { return pName; }
 
   TraceMap pTraces;
-};
 
-/** Static Os Controller */
+ private:
-class OS {
+  const std::string pName = "StdPd";
- public:
-  OS() = default;
-  ~OS() = default;
-
-  static void Init(OsDriver::Ref v = nullptr) {
-    if (v) {
-      pOs = v;
-    } else {
-      pOs = OsDriver::New();
-    }
-  }
-
-  static u64 GetTime() { return pOs->GetTime(); }
-  static u64 GetNanoTime() { return pOs->GetNanoTime(); }
-  static TraceMap& GetTraceMap() { return pOs->GetTraceMap(); }
-  static TT::Res::Ref& GetTraceRef(const std::string& id) {
-    return pOs->GetTraceRef(id);
-  }
-  static bool TraceExist(const std::string& id) { return pOs->TraceExist(id); }
-
-  static OsDriver::Ref pOs;
 };
 }  // namespace PD

include/pd/drivers/snd.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/drivers/types.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+using PDDriverData = void*;

include/pd/image/image.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,10 +24,10 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
-#include <pd/image/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
-class PD_IMAGE_API Image {
+class PD_API Image {
  public:
   enum Format {
     RGBA,    // bpp == 4
@@ -57,6 +56,7 @@ class PD_IMAGE_API Image {
 
   int Width() const { return pWidth; }
   int Height() const { return pHeight; }
+  ivec2 Size() const { return ivec2(pWidth, pHeight); }
   Format Fmt() const { return pFmt; }
 
   void FlipVertical();

include/pd/image/img_blur.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,7 +24,7 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
-#include <pd/image/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 /**
@@ -38,7 +37,7 @@ namespace ImgBlur {
  * @param si sigma value to use
  * @return list of kernel values
  */
-PD_IMAGE_API std::vector<float> GaussianKernel(int radius, float si);
+PD_API std::vector<float> GaussianKernel(int radius, float si);
 /**
  * Gaussian Blur for basic Image Buffer
  * @param buf Image Buffer (unsigned char)
@@ -48,8 +47,8 @@ PD_IMAGE_API std::vector<float> GaussianKernel(int radius, float si);
  * @param si Blur sigma
  * @param idxfn Indexing function
  */
-PD_IMAGE_API void GaussianBlur(
+PD_API void GaussianBlur(
-    std::vector<u8> &buf, int w, int h, float radius, float si,
+    std::vector<u8>& buf, int w, int h, float radius, float si,
     std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
       return y * w + x;
     });
@@ -63,8 +62,8 @@ PD_IMAGE_API void GaussianBlur(
  * @param si Blur sigma
  * @param idxfn Indexing function
  */
-PD_IMAGE_API void GaussianBlur(
+PD_API void GaussianBlur(
-    void *buf, int w, int h, int bpp, float radius, float si,
+    void* buf, int w, int h, int bpp, float radius, float si,
     std::function<int(int, int, int)> idxfn = [](int x, int y, int w) -> int {
       return y * w + x;
     });

include/pd/image/img_convert.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,7 +25,7 @@ SOFTWARE.
 
 #include <pd/core/core.hpp>
 #include <pd/image/image.hpp>
-#include <pd/image/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 /**
@@ -41,19 +40,19 @@ namespace ImgConvert {
  * @param w width of the image
  * @param h height of the image
  */
-PD_IMAGE_API
+PD_API
-void RGB24toRGBA32(std::vector<PD::u8> &out, const std::vector<u8> &in,
+void RGB24toRGBA32(std::vector<PD::u8>& out, const std::vector<u8>& in,
-                   const int &w, const int &h);
+                   const int& w, const int& h);
-PD_IMAGE_API
+PD_API
-void RGB32toRGBA24(std::vector<u8> &out, const std::vector<u8> &in,
+void RGB32toRGBA24(std::vector<u8>& out, const std::vector<u8>& in,
-                   const int &w, const int &h);
+                   const int& w, const int& h);
 /**
  * Reverse 32 (RGBA -> ABGR || ABGR -> RGBA)
  * @param buf Buffer to convert
  * @param w width
  * @param h height
  */
-PD_IMAGE_API void Reverse32(std::vector<u8> &buf, const int &w, const int &h);
+PD_API void Reverse32(std::vector<u8>& buf, const int& w, const int& h);
-PD_IMAGE_API void ReverseBuf(std::vector<u8> &buf, size_t bpp, int w, int h);
+PD_API void ReverseBuf(std::vector<u8>& buf, size_t bpp, int w, int h);
 }  // namespace ImgConvert
 }  // namespace PD

include/pd/image/pd_p_api.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-/** Generated with ppam */
-
-#ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_IMAGE_BUILD_SHARED
-#define PD_IMAGE_API __declspec(dllexport)
-#else
-#define PD_IMAGE_API __declspec(dllimport)
-#endif
-#elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_IMAGE_BUILD_SHARED
-#define PD_IMAGE_API __attribute__((visibility("default")))
-#else
-#define PD_IMAGE_API
-#endif
-#elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_IMAGE_BUILD_SHARED
-#define PD_IMAGE_API __attribute__((visibility("default")))
-#else
-#define PD_IMAGE_API
-#endif
-#elif defined(__3DS__)  // 3ds Specific
-// Only Static supported
-#define PD_IMAGE_API
-#else
-#define PD_IMAGE_API
-#endif

include/pd/lithium/command.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,6 +26,7 @@ SOFTWARE.
 #include <pd/core/core.hpp>
 #include <pd/lithium/texture.hpp>
 #include <pd/lithium/vertex.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 namespace Li {
@@ -34,7 +35,7 @@ class Command {
   Command() = default;
   ~Command() = default;
 
-  PD_UNIQUE(Command);
+  PD_RAW(Command);
 
   Command& AddIdx(const u16& idx) {
     IndexBuffer.push_back(VertexBuffer.size() + idx);
@@ -52,13 +53,51 @@ class Command {
     return *this;
   }
 
+  void Clear() {
+    VertexBuffer.clear();
+    IndexBuffer.clear();
+    Index = 0;
+    Layer = 0;
+    Tex = 0;
+    ScissorOn = false;
+    ScissorRect = ivec4();
+  }
+
   std::vector<Vertex> VertexBuffer;
   std::vector<u16> IndexBuffer;
   ivec4 ScissorRect;
   bool ScissorOn = false;
-  int Layer;
+  int Layer = 0;
-  int Index;
+  int Index = 0;
-  Texture::Ref Tex;
+  TexAddress Tex;
+};
+
+class PD_API CmdPool {
+ public:
+  CmdPool() {}
+  ~CmdPool() {}
+
+  Command::Ref NewCmd();
+  void Init(size_t initial_size);
+  void Deinit();
+  void Resize(size_t nulen);
+  void Reset();
+  Command::Ref GetCmd(size_t idx) const;
+  Command::Ref GetCmd(size_t idx);
+  size_t Size() const;
+  size_t Cap() const;
+  void Merge(CmdPool& p);
+  void Copy(CmdPool& p);
+  void Sort();
+
+ private:
+  static bool pTheOrder(const Command::Ref& a, const Command::Ref& b);
+  friend class DrawList;
+  Command::Ref* begin() { return &pPool[0]; }
+  Command::Ref* end() { return &pPool[pPoolIdx - 1]; }
+  std::vector<Command::Ref> pPool;
+  u32 pPoolIdx = 0;
+  int Layer = 0;
 };
 }  // namespace Li
 }  // namespace PD

include/pd/lithium/drawlist.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,7 +25,7 @@ SOFTWARE.
 
 #include <pd/lithium/command.hpp>
 #include <pd/lithium/font.hpp>
-#include <pd/lithium/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 /** Path Rect Flags */
 using LiPathRectFlags = PD::u32;
@@ -46,10 +45,10 @@ enum LiPathRectFlags_ : PD::u32 {
 
 namespace PD {
 namespace Li {
-class PD_LITHIUM_API DrawList {
+class PD_API DrawList {
  public:
-  DrawList() { DrawSolid(); }
+  DrawList(Context& ctx, int initial_size = 64);
-  ~DrawList() { pDrawList.clear(); }
+  ~DrawList();
 
   /** Require Copy and Move Constructors */
 
@@ -81,19 +80,18 @@ class PD_LITHIUM_API DrawList {
    */
   void Optimize();
 
-  Command::Ref PreGenerateCmd();
+  Command::Ref GetNewCmd();
-  void AddCommand(Command::Ref v);
   void Clear();
-  void Layer(int l) { this->pLayer = l; }
+  void Layer(int l) { this->pPool.Layer = l; }
-  int Layer() { return this->pLayer; }
+  int Layer() { return this->pPool.Layer; }
-  void LayerUp() { this->pLayer++; }
+  void LayerUp() { this->pPool.Layer++; }
-  void LayerDown() { this->pLayer--; }
+  void LayerDown() { this->pPool.Layer--; }
 
   void SetFont(Font::Ref font) { pCurrentFont = font; }
   void SetFontScale(float scale) { pFontScale = scale; }
 
   void DrawSolid();
-  void DrawTexture(Texture::Ref tex) { CurrentTex = tex; }
+  void DrawTexture(Texture::Ref tex);
 
   // SECTION: Draw API //
 
@@ -206,21 +204,21 @@ class PD_LITHIUM_API DrawList {
     }
     pClipRects.pop();
   }
-  const std::vector<Command::Ref>& Data() const { return pDrawList; }
+  const CmdPool& Data() const { return pPool; }
   /** One linear Clip rect Setup */
   void pClipCmd(Command* cmd);
 
   /** Data Section */
 
   std::stack<fvec4> pClipRects;
-  int pLayer;
   float pFontScale = 0.7f;
   Font::Ref pCurrentFont;
   Texture::Ref CurrentTex;
-  std::vector<Command::Ref> pDrawList;
+  CmdPool pPool;
   std::vector<fvec2> pPath;
   u32 pNumIndices = 0;
   u32 pNumVertices = 0;
+  Context* pCtx = nullptr;
 };
 }  // namespace Li
 }  // namespace PD

include/pd/lithium/font.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,9 +25,9 @@ SOFTWARE.
 
 #include <pd/core/core.hpp>
 #include <pd/lithium/command.hpp>
-#include <pd/lithium/pd_p_api.hpp>
 #include <pd/lithium/rect.hpp>
 #include <pd/lithium/texture.hpp>
+#include <pd/pd_p_api.hpp>
 
 using LiTextFlags = PD::u32;
 enum LiTextFlags_ {
@@ -43,8 +42,10 @@ enum LiTextFlags_ {
 };
 
 namespace PD {
+class Context;
 namespace Li {
-class PD_LITHIUM_API Font {
+class DrawList;
+class PD_API Font {
  public:
   /** Codepoint Data holder */
   struct Codepoint {
@@ -57,7 +58,7 @@ class PD_LITHIUM_API Font {
   };
 
   /** Constructore doesnt need Backand anymore */
-  Font() = default;
+  Font(Context& ctx) : pCtx(ctx) {}
   ~Font() = default;
 
   PD_SHARED(Font);
@@ -93,8 +94,8 @@ class PD_LITHIUM_API Font {
   /**
    * Extended Draw Text Function that vreates a Command List
    */
-  void CmdTextEx(std::vector<Command::Ref>& cmds, const fvec2& pos, u32 color,
+  void CmdTextEx(DrawList& dl, const fvec2& pos, u32 color, float scale,
-                 float scale, const std::string& text, LiTextFlags flags = 0,
+                 const std::string& text, LiTextFlags flags = 0,
                  const fvec2& box = 0);
 
   /**
@@ -129,6 +130,7 @@ class PD_LITHIUM_API Font {
     u64 TimeStamp;
   };
   std::unordered_map<u32, TMELEM> pTMS;
+  Context& pCtx;
 };
 }  // namespace Li
 }  // namespace PD

include/pd/lithium/fonts.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -37,5 +37,5 @@ struct FontFileData {
 extern FontFileData pFontData[];
 extern size_t pNumFonts;
 extern PD::u8 pFontsDataRaw[];
-}   // namespace PD
+}  // namespace PD
 #endif

include/pd/lithium/lithium.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/lithium/pd_p_api.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-/** Generated with ppam */
-
-#ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_LITHIUM_BUILD_SHARED
-#define PD_LITHIUM_API __declspec(dllexport)
-#else
-#define PD_LITHIUM_API __declspec(dllimport)
-#endif
-#elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_LITHIUM_BUILD_SHARED
-#define PD_LITHIUM_API __attribute__((visibility("default")))
-#else
-#define PD_LITHIUM_API
-#endif
-#elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_LITHIUM_BUILD_SHARED
-#define PD_LITHIUM_API __attribute__((visibility("default")))
-#else
-#define PD_LITHIUM_API
-#endif
-#elif defined(__3DS__)  // 3ds Specific
-// Only Static supported
-#define PD_LITHIUM_API
-#else
-#define PD_LITHIUM_API
-#endif

include/pd/lithium/rect.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -131,6 +131,8 @@ class Rect {
     return *this;
   }
 
+  bool operator==(const Rect& r) const { return Top == r.Top && Bot == r.Bot; }
+
   void SwapVec2XY() {
     Top.SwapXY();
     Top.SwapZW();

include/pd/lithium/renderer.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,15 +24,15 @@ SOFTWARE.
  */
 
 #include <pd/drivers/drivers.hpp>
-#include <pd/lithium/pd_p_api.hpp>
 #include <pd/lithium/rect.hpp>
+#include <pd/pd_p_api.hpp>
 
 namespace PD {
 namespace Li {
 /**
  * Static Class Render Setup Functions
  */
-class PD_LITHIUM_API Renderer {
+class PD_API Renderer {
  public:
   Renderer() = default;
   ~Renderer() = default;

include/pd/lithium/texture.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

include/pd/lithium/vertex.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -38,6 +38,8 @@ class Vertex {
   }
   ~Vertex() {}
 
+  PD_RAW(Vertex);
+
   // private:
 
   /** Open Access Data Section */

include/pd/pd_p_api.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,28 +24,31 @@ SOFTWARE.
  */
 
 /** Generated with ppam */
-
+#ifndef PD_BUILD_STATIC
 #ifdef _WIN32  // Windows (MSVC Tested)
-#ifdef PD_UI7_BUILD_SHARED
+#ifdef PD_BUILD_SHARED
-#define PD_UI7_API __declspec(dllexport)
+#define PD_API __declspec(dllexport)
 #else
-#define PD_UI7_API __declspec(dllimport)
+#define PD_API __declspec(dllimport)
 #endif
 #elif defined(__APPLE__)  // macOS (untested yet)
-#ifdef PD_UI7_BUILD_SHARED
+#ifdef PD_BUILD_SHARED
-#define PD_UI7_API __attribute__((visibility("default")))
+#define PD_API __attribute__((visibility("default")))
 #else
-#define PD_UI7_API
+#define PD_API
 #endif
 #elif defined(__linux__)  // Linux (untested yet)
-#ifdef PD_UI7_BUILD_SHARED
+#ifdef PD_BUILD_SHARED
-#define PD_UI7_API __attribute__((visibility("default")))
+#define PD_API __attribute__((visibility("default")))
 #else
-#define PD_UI7_API
+#define PD_API
 #endif
 #elif defined(__3DS__)  // 3ds Specific
 // Only Static supported
-#define PD_UI7_API
+#define PD_API
 #else
-#define PD_UI7_API
+#define PD_API
+#endif
+#else
+#define PD_API
 #endif

include/pd/ui7/container/button.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -35,7 +35,7 @@ namespace UI7 {
  * This only means that InPressed is responding the info in
  * the next frame
  */
-class PD_UI7_API Button : public Container {
+class PD_API Button : public Container {
  public:
   /**
    * Button Object constructor

include/pd/ui7/container/checkbox.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -33,7 +33,7 @@ namespace UI7 {
  * Context::Update while the visual update is done
  * during the Update
  */
-class PD_UI7_API Checkbox : public Container {
+class PD_API Checkbox : public Container {
  public:
   /**
    * Constructor for Checkbox Object

include/pd/ui7/container/coloredit.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -32,7 +32,7 @@ namespace UI7 {
 /**
  * Color Editor (Creating a PopUP when clicking)
  */
-class PD_UI7_API ColorEdit : public Container {
+class PD_API ColorEdit : public Container {
  public:
   /**
    * Constructor

include/pd/ui7/container/container.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,8 +24,8 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/pd_p_api.hpp>
 #include <pd/ui7/io.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 
 namespace PD {
 namespace UI7 {
@@ -33,7 +33,7 @@ namespace UI7 {
  * Container base class all Objects are based on
  * @note this class can be used to create custom Objects as well
  */
-class PD_UI7_API Container {
+class PD_API Container {
  public:
   Container() = default;
   /**
@@ -113,6 +113,11 @@ class PD_UI7_API Container {
   /** Template function to update internal data (if needed) */
   virtual void Update() {}
 
+  /** Internal function */
+  void PreDraw();
+  /** Internal function */
+  void PostDraw();
+
   /** Internal Input Handler */
   void HandleInternalInput();
 

include/pd/ui7/container/dragdata.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -33,7 +33,7 @@ namespace UI7 {
  * and modifys these by moving left or right when dragging
  */
 template <typename T>
-class PD_UI7_API DragData : public Container {
+class PD_API DragData : public Container {
  public:
   /**
    * Constructor

include/pd/ui7/container/dynobj.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -36,7 +35,7 @@ namespace UI7 {
  * This only means that InPressed is responding the info in
  * the next frame
  */
-class PD_UI7_API DynObj : public Container {
+class PD_API DynObj : public Container {
  public:
   /**
    * Button Object constructor

include/pd/ui7/container/image.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -30,7 +30,7 @@ namespace UI7 {
 /**
  * Image Object
  */
-class PD_UI7_API Image : public Container {
+class PD_API Image : public Container {
  public:
   /**
    * Constructor for the Image Object
@@ -38,14 +38,17 @@ class PD_UI7_API Image : public Container {
    * @param size Custom Size of the Image
    */
   Image(Li::Texture::Ref img, fvec2 size = 0.f, Li::Rect uv = fvec4(0.f)) {
+    if (!img) return;
     this->img = img;
-    this->newsize = size;
+    if (size == fvec2(0.f)) {
-    this->cuv = uv;
+      size = img->GetSize();
-    if (size.x != 0 || size.y != 0) {
-      this->SetSize(size);
-    } else {
-      this->SetSize(fvec2(img->GetSize().x, img->GetSize().y));
     }
+    if (uv == Li::Rect(fvec4(0.f))) {
+      uv = img->GetUV();
+    }
+    this->cuv = uv;
+    this->newsize = size;
+    SetSize(size);
   }
   ~Image() = default;
 
@@ -58,9 +61,9 @@ class PD_UI7_API Image : public Container {
   void Draw() override;
 
  private:
-  Li::Texture::Ref img;  ///< Texture reference to the Image
+  Li::Texture::Ref img = nullptr;  ///< Texture reference to the Image
-  fvec2 newsize = 0.f;   ///< New Size
+  fvec2 newsize = 0.f;             ///< New Size
-  Li::Rect cuv;          ///< Custom UV
+  Li::Rect cuv;                    ///< Custom UV
 };
 }  // namespace UI7
 }  // namespace PD

include/pd/ui7/container/label.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -30,7 +30,7 @@ namespace UI7 {
 /**
  * Label [Text] Object
  */
-class PD_UI7_API Label : public Container {
+class PD_API Label : public Container {
  public:
   /**
    * Constructor for Label Object

include/pd/ui7/container/slider.hpp

@@ -0,0 +1,91 @@
+#pragma once
+
+/*
+MIT License
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+
+#include <pd/ui7/container/container.hpp>
+#include <pd/ui7/io.hpp>
+
+namespace PD {
+namespace UI7 {
+/**
+ * Slider Object can take a datatype or a list
+ * and modifys these by moving left or right when dragging
+ */
+template <typename T>
+class PD_API Slider : public Container {
+ public:
+  /**
+   * Constructor
+   * @param label Label of the Button
+   * @param data Data reference (Supported types can be seen in Slider.cpp)
+   * @param num_elms Number of Array elements (for exaple with use ofvec4)
+   * @param io IO Reference
+   * @param min minimum number using Minimum limit
+   * @param max Maximum number set by max limit by default
+   * @param step To set the modifier for drag movement
+   * @param precision for float and double to set precision
+   */
+  Slider(const std::string& label, T* data, UI7::IO::Ref io,
+         T min = std::numeric_limits<T>::min(),
+         T max = std::numeric_limits<T>::max(), int precision = 1) {
+    // PD::Assert(data != nullptr, "Input Data Address is null!");
+    this->label = label;
+    this->data = data;
+    this->min = min;
+    this->max = max;
+    this->precision = precision;
+    this->width = io->CurrentViewPort->pSize.z * 0.3f;
+    this->tdim = io->Font->GetTextBounds(label, io->FontScale);
+  }
+  ~Slider() = default;
+
+  /** Als ob das funktioniert... */
+  PD_SHARED(Slider<T>);
+  /**
+   * Override for the Input Handler
+   * @note This function is usally called by Menu::Update
+   */
+  void HandleInput() override;
+  /**
+   * Override for the Rendering Handler
+   * @note This function is usally called by Menu::Update
+   * */
+  void Draw() override;
+
+  /** Function to Update Size if framepadding changes */
+  void Update() override;
+
+ private:
+  fvec2 tdim;         ///< Text size
+  float width;        ///< Size
+  std::string label;  ///< Label of the Button
+  T* data;
+  T min;
+  T max;
+  int precision = 1;
+  float slw = 0.f;  // silider drag width (calculated in update)
+  float slp = 0.f;  // silider drag pos (calculated in update)
+};
+}  // namespace UI7
+}  // namespace PD

include/pd/ui7/containers.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -30,3 +30,4 @@ SOFTWARE.
 #include <pd/ui7/container/dynobj.hpp>
 #include <pd/ui7/container/image.hpp>
 #include <pd/ui7/container/label.hpp>
+#include <pd/ui7/container/slider.hpp>

include/pd/ui7/flags.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -47,8 +47,9 @@ enum UI7MenuFlags_ {
   UI7MenuFlags_NoClose = 1 << 9,       ///< Disable Close Button
   UI7MenuFlags_NoScrollbar = 1 << 10,  ///< Hide the Scrollbar
   // POC
-  UI7MenuFlags_Maximize = 1 << 11,  ///< Add a Maximize Button
+  UI7MenuFlags_Maximize = 1 << 11,        ///< Add a Maximize Button
-  UI7MenuFlags_Minimize = 1 << 12,  ///< Add a Minimize Button
+  UI7MenuFlags_Minimize = 1 << 12,        ///< Add a Minimize Button
+  UI7MenuFlags_AlwaysAutoSize = 1 << 13,  ///< Always Auto Resize Menu
   // Enable Horizontal and Vertical Scrolling
   UI7MenuFlags_Scrolling = UI7MenuFlags_HzScrolling | UI7MenuFlags_VtScrolling,
 };

include/pd/ui7/id.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -38,6 +38,7 @@ class ID {
    */
   ID(const std::string& text) {
     pID = PD::Strings::FastHash(text);
+    // pStrName = text;
     pName = text;
   }
   /**
@@ -56,7 +57,7 @@ class ID {
   ~ID() = default;
 
   /** Get The ID Initial Name */
-  constexpr const std::string_view& GetNameView() const { return pName; }
+  // constexpr const std::string_view& GetNameView() const { return pName; }
   const std::string GetName() const { return std::string(pName); }
 
   /** Getter for the raw 32bit int id */
@@ -65,8 +66,9 @@ class ID {
   /** Return the ID when casting to u32 */
   constexpr operator u32() const { return pID; }
 
-  u32 pID;                 ///< Hash of the name
+  u32 pID;            ///< Hash of the name
-  std::string_view pName;  ///< Name
+  std::string pName;  ///< Name
+  // std::string pStrName;    ///< Keep this stringview alive
 };
 }  // namespace UI7
 }  // namespace PD

include/pd/ui7/input_api.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -26,14 +25,16 @@ SOFTWARE.
 
 #include <pd/core/core.hpp>
 #include <pd/lithium/lithium.hpp>
+#include <pd/pd_p_api.hpp>
 #include <pd/ui7/id.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 
 namespace PD {
 namespace UI7 {
 class InputHandler {
  public:
-  InputHandler() { DragTime = Timer::New(false); }
+  InputHandler(PD::Context& ctx) : pCtx(ctx) {
+    DragTime = Timer::New(*pCtx.Os().get(), false);
+  }
   ~InputHandler() = default;
 
   PD_SHARED(InputHandler);
@@ -56,10 +57,10 @@ class InputHandler {
       }
     }
     // Get a Short define for touch pos
-    fvec2 p = Hid::MousePos();
+    fvec2 p = pCtx.Hid()->MousePos();
     // Check if Drag starts in the area position
-    if ((Hid::IsDown(Hid::Key::Touch) ||
+    if ((pCtx.Hid()->IsDown(pCtx.Hid()->Key::Touch) ||
-         Hid::IsEvent(PD::Hid::Event::Event_Down, HidKb::Kb_MouseLeft)) &&
+         pCtx.Hid()->IsEvent(PD::HidDriver::Event_Down, HidKb::Kb_MouseLeft)) &&
         Li::Renderer::InBox(p, area)) {
       // Set ID and iniatial Positions
       DraggedObject = id;
@@ -71,15 +72,16 @@ class InputHandler {
       DragTime->Reset();
       DragTime->Rseume();
       return false;  // To make sure the Object is "Dragged"
-    } else if ((Hid::IsHeld(Hid::Key::Touch) ||
+    } else if ((pCtx.Hid()->IsHeld(pCtx.Hid()->Key::Touch) ||
-                Hid::IsEvent(PD::Hid::Event::Event_Held,
+                pCtx.Hid()->IsEvent(PD::HidDriver::Event_Held,
-                             HidKb::Kb_MouseLeft)) &&
+                                    HidKb::Kb_MouseLeft)) &&
                IsObjectDragged()) {
       // Update DragLast and DragPoisition
       DragLastPosition = DragPosition;
       DragPosition = p;
-    } else if ((Hid::IsUp(Hid::Key::Touch) ||
+    } else if ((pCtx.Hid()->IsUp(pCtx.Hid()->Key::Touch) ||
-                Hid::IsEvent(PD::Hid::Event::Event_Up, HidKb::Kb_MouseLeft)) &&
+                pCtx.Hid()->IsEvent(PD::HidDriver::Event_Up,
+                                    HidKb::Kb_MouseLeft)) &&
                IsObjectDragged()) {
       // Released... Everything gets reset
       DraggedObject = 0;
@@ -89,9 +91,9 @@ class InputHandler {
       DragDestination = fvec4(0);
       // Set Drag released to true (only one frame)
       // and Only if still in Box
-      DragReleased = Li::Renderer::InBox(Hid::MousePosLast(), area);
+      DragReleased = Li::Renderer::InBox(pCtx.Hid()->MousePosLast(), area);
       DragReleasedAW = true;  // Advanced
-      u64 d_rel = PD::OS::GetTime();
+      u64 d_rel = pCtx.Os()->GetTime();
       if (d_rel - DragLastReleased < DoubleClickTime) {
         DragDoubleRelease = true;
         DragLastReleased = 0;  // Set 0 to prevent double exec
@@ -130,6 +132,7 @@ class InputHandler {
   bool DragReleased = false;       ///< Drag Releaded in Box
   bool DragReleasedAW = false;     ///< Drag Released Anywhere
   bool DragDoubleRelease = false;  ///< Double Click
+  PD::Context& pCtx;
   /** Check if an object is Dragged already */
   bool IsObjectDragged() const { return DraggedObject != 0; }
 };

include/pd/ui7/io.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,26 +24,27 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/pd_p_api.hpp>
 #include <pd/ui7/input_api.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 #include <pd/ui7/theme.hpp>
 #include <pd/ui7/viewport.hpp>
 
 namespace PD {
+class Context;
 namespace UI7 {
-class PD_UI7_API IO {
+class PD_API IO {
  public:
-  IO() {
+  IO(PD::Context& ctx) : pCtx(ctx) {
-    Time = Timer::New();
+    Time = Timer::New(*pCtx.Os().get());
-    InputHandler = InputHandler::New();
+    InputHandler = InputHandler::New(pCtx);
     Theme = UI7::Theme::New();
-    Back = Li::DrawList::New();
+    Back = Li::DrawList::New(pCtx);
-    Front = Li::DrawList::New();
+    Front = Li::DrawList::New(pCtx);
-    FDL = Li::DrawList::New();
+    FDL = Li::DrawList::New(pCtx);
     DeltaStats = TimeStats::New(60);
     /** Probably not the best solution i guess */
-    CurrentViewPort.z = PD::Gfx::pGfx->ViewPort.x;
+    CurrentViewPort =
-    CurrentViewPort.w = PD::Gfx::pGfx->ViewPort.y;
+        ViewPort::New("Default", ivec4(ivec2(0, 0), pCtx.Gfx()->ViewPort));
   }
   ~IO() {}
 
@@ -61,7 +61,8 @@ class PD_UI7_API IO {
    * Possible thanks to the DrawList::Merge Feature
    */
   Li::DrawList::Ref FDL = nullptr;
-  ivec4 CurrentViewPort = ivec4(0, 0, 0, 0);
+  ViewPort::Ref CurrentViewPort;
+  // ivec4 CurrentViewPort = ivec4(0, 0, 0, 0);
   std::unordered_map<u32, ViewPort::Ref> ViewPorts;
   float Framerate = 0.f;
   float Delta = 0.f;
@@ -73,6 +74,8 @@ class PD_UI7_API IO {
   UI7::Theme::Ref Theme;
   fvec2 MenuPadding = 5.f;
   fvec2 FramePadding = 5.f;
+  float ItemRowHeight = 0.f;
+  float FrameRounding = 0.f;
   fvec2 ItemSpace = vec2(5.f, 2.f);
   fvec2 MinSliderDragSize = 10.f;  // Min height (Vt) and Min Width (Hz)
   bool ShowMenuBorder = true;
@@ -89,6 +92,8 @@ class PD_UI7_API IO {
   u32 NumIndices = 0;   ///< Debug Indices Num
   std::vector<u32> MenuOrder;
 
+  PD::Context& pCtx;  // Palladium base context
+
   // DrawListApi
   void RegisterDrawList(const UI7::ID& id, Li::DrawList::Ref v) {
     DrawListRegestry.push_back(std::make_pair(id, v));

include/pd/ui7/layout.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,33 +24,100 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/pd_p_api.hpp>
 #include <pd/ui7/container/container.hpp>
+#include <pd/ui7/container/dragdata.hpp>
+#include <pd/ui7/container/slider.hpp>
 #include <pd/ui7/flags.hpp>
 #include <pd/ui7/input_api.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 #include <pd/ui7/theme.hpp>
 
 namespace PD {
 namespace UI7 {
-class PD_UI7_API Layout {
+class Context;
+class PD_API Layout {
  public:
   Layout(const ID& id, IO::Ref io) : ID(id) {
     this->IO = io;
-    DrawList = Li::DrawList::New();
+    DrawList = Li::DrawList::New(io->pCtx);
     DrawList->SetFont(IO->Font);
     DrawList->SetFontScale(io->FontScale);
     Scrolling[0] = false;
     Scrolling[1] = false;
     CursorInit();
-    Pos = fvec2(io->CurrentViewPort.x, io->CurrentViewPort.y);
+    Pos = fvec2(io->CurrentViewPort->pSize.x, io->CurrentViewPort->pSize.y);
-    Size = fvec2(io->CurrentViewPort.z - io->CurrentViewPort.x,
+    Size = 0;
-                 io->CurrentViewPort.w - io->CurrentViewPort.y);
     WorkRect = fvec4(IO->MenuPadding, Size - (fvec2(2) * IO->MenuPadding));
   }
   ~Layout() = default;
 
   PD_SHARED(Layout);
 
+  /** SECTION CONTAINERS */
+  /**
+   * Render a Simple Label
+   * @param label The text to draw
+   */
+  void Label(const std::string& label);
+  template <typename... Args>
+  void Label(std::format_string<Args...> s, Args&&... args) {
+    Label(std::format(s, std::forward<Args>(args)...));
+  }
+  /**
+   * Render a Button
+   * @param label The buttons text
+   * @return if the button was pressed
+   */
+  bool Button(const std::string& label);
+  /**
+   * Render a Checkbox
+   * @param label Label of the Checkbox
+   * @param v A value to update
+   */
+  void Checkbox(const std::string& label, bool& v);
+  /**
+   * Render an Image
+   * @param img Texture reference of the image
+   * @param size a Custom Size if needed
+   */
+  void Image(Li::Texture::Ref img, fvec2 size = 0.f, Li::Rect uv = fvec4(0));
+  /**
+   * Render a Drag Object witth any supported type:
+   * [`int`, `float`, `double`, `u8`, `u16`, `u32`]
+   * @param label Name of the Drag
+   * @param data Reference to Data Object (can be multiple as well)
+   * @param num_elements Defien the number of Elements in the Data addr
+   * @param precission Difine the Format string len for float/double
+   */
+  template <typename T>
+  void DragData(const std::string& label, T* data, size_t num_elms = 1,
+                T min = std::numeric_limits<T>::min(),
+                T max = std::numeric_limits<T>::max(), T step = 1,
+                int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = FindObject(id);
+    if (!r) {
+      r = UI7::DragData<T>::New(label, data, num_elms, this->IO, min, max, step,
+                                precision);
+      r->SetID(id);
+    }
+    AddObject(r);
+  }
+  template <typename T>
+  void Slider(const std::string& label, T* data,
+              T min = std::numeric_limits<T>::min(),
+              T max = std::numeric_limits<T>::max(), int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = FindObject(id);
+    if (!r) {
+      r = UI7::Slider<T>::New(label, data, this->IO, min, max, precision);
+      r->SetID(id);
+    }
+    AddObject(r);
+  }
+
+  /** SECTION OTHERSTUFF */
+
   const std::string GetName() const { return ID.GetName(); }
   const UI7::ID& GetID() const { return this->ID; }
 
@@ -107,12 +173,13 @@ class PD_UI7_API Layout {
 
  private:
   friend class Menu;
-  friend class Context;
+  friend class PD::UI7::Context;
   friend class ReMenu;
   // Base Components
   UI7::ID ID;
   UI7::IO::Ref IO;
   Li::DrawList::Ref DrawList;
+  UI7LayoutFlags Flags;
 
   // Positioning
   fvec2 Pos;

include/pd/ui7/menu.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,17 +24,18 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/pd_p_api.hpp>
+#include <pd/ui7/containers.hpp>
 #include <pd/ui7/io.hpp>
 #include <pd/ui7/layout.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 
 #include "pd/ui7/container/dragdata.hpp"
 
 namespace PD {
 namespace UI7 {
-class PD_UI7_API Menu {
+class PD_API Menu {
  public:
-  Menu(const UI7::ID &id, UI7::IO::Ref pIO);
+  Menu(const UI7::ID& id, UI7::IO::Ref pIO);
   ~Menu() {}
 
   PD_SHARED(Menu);
@@ -44,9 +44,9 @@ class PD_UI7_API Menu {
    * Render a Simple Label
    * @param label The text to draw
    */
-  void Label(const std::string &label);
+  void Label(const std::string& label);
   template <typename... Args>
-  void Label(std::format_string<Args...> s, Args &&...args) {
+  void Label(std::format_string<Args...> s, Args&&... args) {
     Label(std::format(s, std::forward<Args>(args)...));
   }
   /**
@@ -54,13 +54,13 @@ class PD_UI7_API Menu {
    * @param label The buttons text
    * @return if the button was pressed
    */
-  bool Button(const std::string &label);
+  bool Button(const std::string& label);
   /**
    * Render a Checkbox
    * @param label Label of the Checkbox
    * @param v A value to update
    */
-  void Checkbox(const std::string &label, bool &v);
+  void Checkbox(const std::string& label, bool& v);
   /**
    * Render an Image
    * @param img Texture reference of the image
@@ -76,7 +76,7 @@ class PD_UI7_API Menu {
    * @param precission Difine the Format string len for float/double
    */
   template <typename T>
-  void DragData(const std::string &label, T *data, size_t num_elms = 1,
+  void DragData(const std::string& label, T* data, size_t num_elms = 1,
                 T min = std::numeric_limits<T>::min(),
                 T max = std::numeric_limits<T>::max(), T step = 1,
                 int precision = 1) {
@@ -92,10 +92,23 @@ class PD_UI7_API Menu {
     }
     pLayout->AddObject(r);
   }
+  template <typename T>
+  void Slider(const std::string& label, T* data,
+              T min = std::numeric_limits<T>::min(),
+              T max = std::numeric_limits<T>::max(), int precision = 1) {
+    u32 id = Strings::FastHash("drd" + label + std::to_string((uintptr_t)data));
+    Container::Ref r = pLayout->FindObject(id);
+    if (!r) {
+      r = UI7::Slider<T>::New(label, data, pIO, min, max, precision);
+      r->SetID(id);
+    }
+    pLayout->AddObject(r);
+  }
+  void ColorEdit(const std::string& label, u32& clr);
   void SameLine() { pLayout->SameLine(); }
   void Separator();
-  void SeparatorText(const std::string &label);
+  void SeparatorText(const std::string& label);
-  bool BeginTreeNode(const ID &id);
+  bool BeginTreeNode(const ID& id);
   void EndTreeNode();
 
   void HandleFocus();
@@ -107,16 +120,22 @@ class PD_UI7_API Menu {
   void AddObjectEx(PD::UI7::Container::Ref obj, PD::u32 flags) {
     pLayout->AddObjectEx(obj, flags);
   }
+  Container::Ref FindObject(u32 id) { return pLayout->FindObject(id); }
 
   void Update();
 
+  void SetSize(PD::fvec2 size) { pLayout->SetSize(size); }
+  void SetPosition(PD::fvec2 pos) { pLayout->SetPosition(pos); }
+  const PD::fvec2& GetSize() const { return pLayout->GetSize(); }
+  const PD::fvec2& GetPosition() const { return pLayout->GetPosition(); }
+
   /** Data Section */
 
   UI7MenuFlags Flags = 0;
   Layout::Ref pLayout;
   IO::Ref pIO;
   ID pID;
-  bool *pIsShown = nullptr;
+  bool* pIsShown = nullptr;
   bool pIsOpen = true;
   std::unordered_map<u32, bool> pTreeNodes;
   fvec2 TempScrollXY;

include/pd/ui7/theme.hpp

@@ -2,7 +2,7 @@
 
 /*
 MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -24,7 +24,7 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
-#include <pd/ui7/pd_p_api.hpp>
+#include <pd/pd_p_api.hpp>
 
 /**
  *  Using this to support 32bit color values as well as
@@ -55,7 +55,7 @@ enum UI7Color_ {
 
 namespace PD {
 namespace UI7 {
-class PD_UI7_API Theme {
+class PD_API Theme {
  public:
   /**
    * Default Constructor Setting up the Default theme

include/pd/ui7/ui7.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -25,9 +24,9 @@ SOFTWARE.
  */
 
 #include <pd/core/core.hpp>
+#include <pd/pd_p_api.hpp>
 #include <pd/ui7/io.hpp>
 #include <pd/ui7/menu.hpp>
-#include <pd/ui7/pd_p_api.hpp>
 
 #include "pd/ui7/flags.hpp"
 
@@ -46,11 +45,11 @@ namespace UI7 {
  * @param show_build Show build num (mostly unused)
  * @return Version String (1.0.0-1 for example)
  */
-PD_UI7_API std::string GetVersion(bool show_build = false);
+PD_API std::string GetVersion(bool show_build = false);
 /** Base Context for UI7 */
-class PD_UI7_API Context {
+class PD_API Context {
  public:
-  Context() { pIO = IO::New(); }
+  Context(PD::Context& ctx) { pIO = IO::New(ctx); }
   ~Context() = default;
 
   PD_SHARED(Context);
@@ -59,7 +58,8 @@ class PD_UI7_API Context {
   void AddViewPort(const ID& id, const ivec4& vp);
   void UseViewPort(const ID& id);
   void Update();
-  bool BeginMenu(const ID& id, UI7MenuFlags flags = 0, bool* pShow = nullptr);
+  Menu::Ref BeginMenu(const ID& id, UI7MenuFlags flags = 0,
+                      bool* pShow = nullptr);
   Menu::Ref CurrentMenu() { return pCurrent; }
   void EndMenu();
   void AboutMenu(bool* show = nullptr);

include/pd/ui7/viewport.hpp

@@ -2,8 +2,7 @@
 
 /*
 MIT License
-
+Copyright (c) 2024 - 2026 René Amthor (tobid7)
-Copyright (c) 2024 - 2025 tobid7
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

pd/core/CMakeLists.txt

@@ -1,21 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-project(pd-core LANGUAGES CXX VERSION 0.6.0)
-
-set(SRC
-    source/bit_util.cpp
-    source/color.cpp
-    source/io.cpp
-    source/mat.cpp
-    source/strings.cpp
-    source/timer.cpp
-    source/timetrace.cpp
-)
-
-if(PD_BUILD_SHARED)
-    pd_add_lib(pd-core BUILD_SHARED TRUE SRC_FILES ${SRC})
-else()
-    pd_add_lib(pd-core SRC_FILES ${SRC})
-endif()
-
-target_link_libraries(pd-core PUBLIC pd-drivers)

pd/drivers/CMakeLists.txt

@@ -1,13 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-## The Core Core Library
-project(pd-drivers LANGUAGES CXX VERSION 0.6.0)
-
-set(SRC
-    source/hid.cpp
-    source/os.cpp
-    source/gfx.cpp
-)
-
-# Only Static Supported
-pd_add_lib(pd-drivers SRC_FILES ${SRC})

pd/drivers/source/hid.cpp

@@ -1,39 +0,0 @@
-#include <pd/drivers/hid.hpp>
-#include <pd/drivers/pd_p_api.hpp>
-
-namespace PD {
-PD_DEF_EXP(HidDriver::Ref, Hid::pHid);
-
-bool HidDriver::IsEvent(Event e, Key keys) { return KeyEvents[0][e] & keys; }
-bool HidDriver::IsEvent(Event e, KbKey keys) {
-  return KbKeyEvents[0][e].Has(keys);
-}
-
-void HidDriver::SwapTab() {
-  auto tkd = KeyEvents[1][Event_Down];
-  auto tkh = KeyEvents[1][Event_Held];
-  auto tku = KeyEvents[1][Event_Up];
-  KeyEvents[1][Event_Down] = KeyEvents[0][Event_Down];
-  KeyEvents[1][Event_Held] = KeyEvents[0][Event_Held];
-  KeyEvents[1][Event_Up] = KeyEvents[0][Event_Up];
-  KeyEvents[0][Event_Down] = tkd;
-  KeyEvents[0][Event_Held] = tkh;
-  KeyEvents[0][Event_Up] = tku;
-}
-
-/**
- * If this func has no verride, still clear the stats
- * cause if they are empty this leads to a crash
- */
-void HidDriver::Update() {
-  // Clear States
-  for (int i = 0; i < 2; i++) {
-    KeyEvents[i][Event_Down] = 0;
-    KeyEvents[i][Event_Held] = 0;
-    KeyEvents[i][Event_Up] = 0;
-    for (auto& it : KbKeyEvents[i]) {
-      it.second = Event_Null;
-    }
-  }
-}
-}  // namespace PD

pd/external/CMakeLists.txt

@@ -1,9 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-project(pd-external LANGUAGES CXX VERSION 0.5.0)
-
-set(SRC
-    source/stb.cpp
-)
-
-pd_add_lib(pd-external SRC_FILES ${SRC})

pd/external/source/stb.cpp

@@ -1,4 +0,0 @@
-#define STB_IMAGE_IMPLEMENTATION
-#include <pd/external/stb_image.h>
-#define STB_TRUETYPE_IMPLEMENTATION
-#include <pd/external/stb_truetype.h>

pd/image/CMakeLists.txt

@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-project(pd-image LANGUAGES CXX VERSION 0.5.0)
-
-set(SRC
-    source/image.cpp
-    source/img_blur.cpp
-    source/img_convert.cpp
-)
-
-if(PD_BUILD_SHARED)
-    pd_add_lib(pd-image BUILD_SHARED TRUE SRC_FILES ${SRC})
-else()
-    pd_add_lib(pd-image SRC_FILES ${SRC})
-endif()

pd/lithium/CMakeLists.txt

@@ -1,26 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-project(pd-lithium LANGUAGES CXX VERSION 0.6.0)
-
-option(PD_LI_INCLUDE_FONTS "Include Fonts" OFF)
-
-set(SRC
-    source/drawlist.cpp
-    source/font.cpp
-    source/fonts.cpp
-    source/renderer.cpp
-)
-
-if(PD_BUILD_SHARED)
-    pd_add_lib(pd-lithium BUILD_SHARED TRUE SRC_FILES ${SRC})
-else()
-    pd_add_lib(pd-lithium SRC_FILES ${SRC})
-endif()
-
-if(${PD_LI_INCLUDE_FONTS})
-    target_compile_definitions(pd-lithium PUBLIC
-        -DPD_LI_INCLUDE_FONTS=1
-    )
-endif()
-
-target_link_libraries(pd-lithium PUBLIC pd-core)

pd/ui7/CMakeLists.txt

@@ -1,28 +0,0 @@
-cmake_minimum_required(VERSION 3.22)
-
-project(pd-ui7 LANGUAGES CXX VERSION 0.6.0)
-
-set(SRC
-    source/theme.cpp
-    source/ui7.cpp
-    source/io.cpp
-    source/layout.cpp
-    source/menu.cpp
-
-    source/container/button.cpp
-    source/container/checkbox.cpp
-    source/container/coloredit.cpp
-    source/container/container.cpp
-    source/container/dragdata.cpp
-    source/container/dynobj.cpp
-    source/container/image.cpp
-    source/container/label.cpp
-)
-
-if(PD_BUILD_SHARED)
-    pd_add_lib(pd-ui7 BUILD_SHARED TRUE SRC_FILES ${SRC})
-else()
-    pd_add_lib(pd-ui7 SRC_FILES ${SRC})
-endif()
-
-target_link_libraries(pd-ui7 PUBLIC pd-lithium pd-core)

pd/ui7/source/container/coloredit.cpp

@@ -1,65 +0,0 @@
-/*
-MIT License
-Copyright (c) 2024 - 2025 René Amthor (tobid7)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- */
-
-#include <pd/ui7/container/coloredit.hpp>
-#include <pd/ui7/container/label.hpp>
-
-namespace PD {
-namespace UI7 {
-PD_UI7_API void ColorEdit::HandleInput() {
-  /// Ensure to only check input once
-  if (inp_done) {
-    return;
-  }
-  // Assert(screen.get(), "Screen is not set up!");
-  // if (screen->ScreenType() == Screen::Bottom) {
-  if (io->InputHandler->DragObject(this->GetID(), fvec4(FinalPos(), size))) {
-    if (io->InputHandler->DragReleased) {
-      is_shown = !is_shown;
-    }
-  }
-  //}
-  inp_done = true;
-}
-PD_UI7_API void ColorEdit::Draw() {
-  // Assert(io.get() && list.get(), "Did you run Container::Init correctly?");
-  // io->Ren->OnScreen(screen);
-  list->DrawRectFilled(FinalPos(), fvec2(20, 20), *color_ref);
-  list->DrawText(FinalPos() + fvec2(io->ItemSpace.x + 20, 0), label,
-                 io->Theme->Get(UI7Color_Text));
-  if (is_shown) {
-    if (!layout) {
-      layout = Layout::New(GetID(), io);
-    }
-    layout->AddObject(Label::New("Hello World!", io));
-    layout->Update();
-    io->RegisterDrawList(GetID(), layout->GetDrawList());
-  }
-}
-
-PD_UI7_API void ColorEdit::Update() {
-  // Assert(io.get(), "Did you run Container::Init correctly?");
-  this->SetSize(fvec2(tdim.x + io->ItemSpace.x + 20, 20));
-}
-}  // namespace UI7
-}  // namespace PD