diff --git a/data/mcswitch_functions.csv b/data/mcswitch_functions.csv
index 876919f4..b5e584ba 100644
--- a/data/mcswitch_functions.csv
+++ b/data/mcswitch_functions.csv
@@ -39371,7 +39371,7 @@ Address,Quality,Size,Name
 0x0000007100607250,U,000468,
 0x0000007100607424,U,001548,
 0x0000007100607a30,U,000004,
-0x0000007100607a34,U,000016,
+0x0000007100607a34,O,000016,_ZNK2nn6Result9IsSuccessEv
 0x0000007100607a44,U,000048,
 0x0000007100607a74,U,000616,
 0x0000007100607cdc,U,000056,
@@ -39763,10 +39763,10 @@ Address,Quality,Size,Name
 0x0000007100618dd0,U,000112,
 0x0000007100618e40,U,000008,
 0x0000007100618e48,U,000100,_ZN13BlockRenderer28tesselateInWorldFixedTextureEPK10BlockStateRK8BlockPosP18TextureAtlasSprite
-0x0000007100618eac,U,001468,_ZN13BlockRenderer16tesselateInWorldEPK10BlockStateRK8BlockPosS2_NSt3__110shared_ptrI11BlockEntityEE
+0x0000007100618eac,M,001468,_ZN13BlockRenderer16tesselateInWorldEPK10BlockStateRK8BlockPosS2_NSt3__110shared_ptrI11BlockEntityEE
 0x0000007100619468,U,000120,
 0x00000071006194e0,U,000020,_ZN13BufferBuilder15setMipmapEnableEb
-0x00000071006194f4,U,000008,
+0x00000071006194f4,O,000008,_ZN5Block15isMipmapEnabledEv
 0x00000071006194fc,U,000336,tesselateBlockInWorld__13BlockRendererFPC10BlockStateRC8BlockPosi
 0x000000710061964c,U,000532,tesselateTrapDoorInWorld__13BlockRendererFPC10BlockStateRC8BlockPos
 0x0000007100619860,U,000120,tesselateSlimeBlockInWorld__13BlockRendererFPC10BlockStateRC8BlockPos
@@ -46196,7 +46196,7 @@ Address,Quality,Size,Name
 0x0000007100794b6c,U,000012,
 0x0000007100794b78,U,000056,_ZN8Renderer14createInstanceEv
 0x0000007100794bb0,U,000004,_GLOBAL__sub_I_RendererCore.cpp
-0x0000007100794bb4,U,000200,_ZN8RendererC1Ev
+0x0000007100794bb4,O,000200,_ZN8RendererC1Ev
 0x0000007100794c7c,U,000020,_ZN9C4JRenderC1Ev
 0x0000007100794c90,U,000008,
 0x0000007100794c98,U,000296,
@@ -46207,24 +46207,24 @@ Address,Quality,Size,Name
 0x00000071007950c4,U,000148,
 0x0000007100795158,U,000012,
 0x0000007100795164,U,000268,
-0x0000007100795270,U,000016,
-0x0000007100795280,U,000016,
-0x0000007100795290,U,000016,
-0x00000071007952a0,U,000016,
-0x00000071007952b0,U,000016,
+0x0000007100795270,O,000016,_ZL27nvnBufferBuilderSetDefaultsP16NVNbufferBuilder
+0x0000007100795280,O,000016,_ZL25nvnBufferBuilderSetDeviceP16NVNbufferBuilderP9NVNdevice
+0x0000007100795290,O,000016,_ZL26nvnBufferBuilderSetStorageP16NVNbufferBuilderP13NVNmemoryPoollm
+0x00000071007952a0,O,000016,_ZL19nvnBufferInitializeP9NVNbufferPK16NVNbufferBuilder
+0x00000071007952b0,O,000016,_ZL12nvnBufferMapPK9NVNbuffer
 0x00000071007952c0,U,000016,
-0x00000071007952d0,U,000016,
+0x00000071007952d0,O,000016,_ZL19nvnBufferGetAddressPK9NVNbuffer
 0x00000071007952e0,U,000016,
 0x00000071007952f0,U,000028,
-0x000000710079530c,U,000744,
-0x00000071007955f4,U,000016,
-0x0000007100795604,U,000792,
+0x000000710079530c,U,000744,_ZN8Renderer11LoadShadersEv
+0x00000071007955f4,O,000016,_ZL19nvnDeviceGetIntegerPK9NVNdevice13NVNdeviceInfoPi
+0x0000007100795604,U,000792,_ZN8Renderer12SetupShadersEv
 0x000000710079591c,U,000016,
 0x000000710079592c,U,000020,
 0x0000007100795940,U,000016,
 0x0000007100795950,U,000040,Renderer::getContext
 0x0000007100795978,U,000048,
-0x00000071007959a8,U,000524,
+0x00000071007959a8,M,000524,_ZN8Renderer7ContextC1EPS_b
 0x0000007100795bb4,U,000004,
 0x0000007100795bb8,U,000016,
 0x0000007100795bc8,U,000016,
@@ -46233,41 +46233,42 @@ Address,Quality,Size,Name
 0x0000007100795c00,U,000016,
 0x0000007100795c10,U,000016,
 0x0000007100795c20,U,000016,
-0x0000007100795c30,U,000008,_ZN8Renderer17InitialiseContextEv
-0x0000007100795c38,U,000072,
-0x0000007100795c80,U,003612,_ZN8Renderer10InitialiseEv
-0x0000007100796a9c,U,000016,
-0x0000007100796aac,U,000004,
-0x0000007100796ab0,U,000004,
-0x0000007100796ab4,U,000016,
-0x0000007100796ac4,U,000020,
-0x0000007100796ad8,U,000016,
-0x0000007100796ae8,U,000020,
-0x0000007100796afc,U,000016,
-0x0000007100796b0c,U,000016,
-0x0000007100796b1c,U,000016,
-0x0000007100796b2c,U,000020,
-0x0000007100796b40,U,000016,
-0x0000007100796b50,U,000016,
-0x0000007100796b60,U,000016,
-0x0000007100796b70,U,000016,
-0x0000007100796b80,U,000016,
-0x0000007100796b90,U,000016,
-0x0000007100796ba0,U,000016,
-0x0000007100796bb0,U,000016,
-0x0000007100796bc0,U,000016,
-0x0000007100796bd0,U,000016,
-0x0000007100796be0,U,000020,
-0x0000007100796bf4,U,000016,
-0x0000007100796c04,U,000016,
-0x0000007100796c14,U,000016,
-0x0000007100796c24,U,000016,
-0x0000007100796c34,U,000016,
-0x0000007100796c44,U,000016,
-0x0000007100796c54,U,000016,
-0x0000007100796c64,U,000016,
-0x0000007100796c74,U,001512,
-0x000000710079725c,U,000040,
+0x0000007100795c30,O,000008,_ZN8Renderer17InitialiseContextEv
+0x0000007100795c38,M,000072,_ZN8Renderer17InitialiseContextEb
+0x0000007100795c80,O,000008,_ZN8Renderer10InitialiseEv
+0x0000007100795c88,O,003604,_ZN8Renderer10InitialiseEb
+0x0000007100796a9c,O,000016,_Z17gfx_aligned_allocmmPv
+0x0000007100796aac,O,000004,_Z8gfx_freePvS_
+0x0000007100796ab0,M,000004,_Z11gfx_reallocPvmS_
+0x0000007100796ab4,O,000016,_ZL27nvnDeviceBuilderSetDefaultsP16NVNdeviceBuilder
+0x0000007100796ac4,O,000020,_ZL24nvnDeviceBuilderSetFlagsP16NVNdeviceBuilderi
+0x0000007100796ad8,O,000016,_ZL19nvnDeviceInitializeP9NVNdevicePK16NVNdeviceBuilder
+0x0000007100796ae8,O,000020,_ZL28nvnDeviceSetWindowOriginModeP9NVNdevice19NVNwindowOriginMode
+0x0000007100796afc,O,000016,_ZL17nvnSyncInitializeP7NVNsyncP9NVNdevice
+0x0000007100796b0c,O,000016,_ZL24nvnQueueBuilderSetDeviceP15NVNqueueBuilderP9NVNdevice
+0x0000007100796b1c,O,000016,_ZL26nvnQueueBuilderSetDefaultsP15NVNqueueBuilder
+0x0000007100796b2c,O,000020,_ZL35nvnQueueBuilderSetComputeMemorySizeP15NVNqueueBuilderm
+0x0000007100796b40,O,000016,_ZL35nvnQueueBuilderSetCommandMemorySizeP15NVNqueueBuilderm
+0x0000007100796b50,O,000016,_ZL39nvnQueueBuilderSetCommandFlushThresholdP15NVNqueueBuilderm
+0x0000007100796b60,O,000016,_ZL33nvnQueueBuilderGetQueueMemorySizePK15NVNqueueBuilder
+0x0000007100796b70,O,000016,_ZL29nvnQueueBuilderSetQueueMemoryP15NVNqueueBuilderPvm
+0x0000007100796b80,O,000016,_ZL18nvnQueueInitializeP8NVNqueuePK15NVNqueueBuilder
+0x0000007100796b90,O,000016,_ZL26nvnCommandBufferInitializeP16NVNcommandBufferP9NVNdevice
+0x0000007100796ba0,O,000016,_ZL26nvnTextureBuilderSetDeviceP17NVNtextureBuilderP9NVNdevice
+0x0000007100796bb0,O,000016,_ZL28nvnTextureBuilderSetDefaultsP17NVNtextureBuilder
+0x0000007100796bc0,O,000016,_ZL25nvnTextureBuilderSetFlagsP17NVNtextureBuilderi
+0x0000007100796bd0,O,000016,_ZL26nvnTextureBuilderSetSize2DP17NVNtextureBuilderii
+0x0000007100796be0,O,000020,_ZL26nvnTextureBuilderSetTargetP17NVNtextureBuilder16NVNtextureTarget
+0x0000007100796bf4,O,000016,_ZL26nvnTextureBuilderSetFormatP17NVNtextureBuilder9NVNformat
+0x0000007100796c04,O,000016,_ZL31nvnTextureBuilderGetStorageSizePK17NVNtextureBuilder
+0x0000007100796c14,O,000016,_ZL36nvnTextureBuilderGetStorageAlignmentPK17NVNtextureBuilder
+0x0000007100796c24,O,000016,_ZL24nvnTexturePoolInitializeP14NVNtexturePoolPK13NVNmemoryPoolli
+0x0000007100796c34,O,000016,_ZL24nvnSamplerPoolInitializeP14NVNsamplerPoolPK13NVNmemoryPoolli
+0x0000007100796c44,O,000016,_ZL27nvnWindowBuilderSetDefaultsP16NVNwindowBuilder
+0x0000007100796c54,O,000016,_ZL25nvnWindowBuilderSetDeviceP16NVNwindowBuilderP9NVNdevice
+0x0000007100796c64,O,000016,_ZL31nvnWindowBuilderSetNativeWindowP16NVNwindowBuilderPv
+0x0000007100796c74,U,001512,_ZN8Renderer14sub_7100796C74Ev
+0x000000710079725c,O,000040,_ZL16nvnWindowSetCropP9NVNwindowiiii
 0x0000007100797284,U,000016,
 0x0000007100797294,U,000016,
 0x00000071007972a4,U,000016,
@@ -46353,15 +46354,15 @@ Address,Quality,Size,Name
 0x0000007100798db0,U,000092,_ZN8Renderer9MatrixGetEi
 0x0000007100798e0c,U,000056,
 0x0000007100798e44,U,000164,_ZN8Renderer15Set_matrixDirtyEv
-0x0000007100798ee8,U,000320,
+0x0000007100798ee8,O,000320,_ZN8Renderer16SetupMemoryPoolsEv
 0x0000007100799028,U,000016,
 0x0000007100799038,U,000016,
 0x0000007100799048,U,000016,
 0x0000007100799058,U,000016,
 0x0000007100799068,U,000016,
-0x0000007100799078,U,000068,
+0x0000007100799078,U,000068,_ZN8Renderer14sub_7100799078Eimm
 0x00000071007990bc,U,000020,
-0x00000071007990d0,U,000024,
+0x00000071007990d0,O,000024,_ZN8Renderer23getNVNMemoryPoolByIndexEj
 0x00000071007990e8,U,000108,
 0x0000007100799154,U,000092,
 0x00000071007991b0,U,000016,
@@ -46920,7 +46921,7 @@ Address,Quality,Size,Name
 0x00000071007b6e88,O,000712,png_do_write_interlace
 0x00000071007b7150,O,003260,png_write_find_filter
 0x00000071007b7e0c,O,000108,png_write_filtered_row
-0x00000071007b7e78,U,000120,
+0x00000071007b7e78,U,000120,_ZN16class_71007B7E78C1Emi
 0x00000071007b7ef0,U,000044,
 0x00000071007b7f1c,U,000148,
 0x00000071007b7fb0,U,000368,
@@ -48351,7 +48352,7 @@ Address,Quality,Size,Name
 0x00000071007eb428,O,000008,zcfree
 0x00000071007eb430,U,000012,Libz_SigloMiddlewareInfo
 0x00000071007eb43c,U,002004,
-0x00000071007ebc10,U,013384,nvnLoadCProcs
+0x00000071007ebc10,O,013384,nvnLoadCProcs
 0x00000071007ef058,U,000068,
 0x00000071007ef09c,U,000024,
 0x00000071007ef0b4,U,000120,
diff --git a/src/Minecraft.Client/platform/NX/Platform.cpp b/src/Minecraft.Client/platform/NX/Platform.cpp
index 046b3c14..92d55561 100644
--- a/src/Minecraft.Client/platform/NX/Platform.cpp
+++ b/src/Minecraft.Client/platform/NX/Platform.cpp
@@ -48,3 +48,15 @@ void XMemDestroyCompressionContext(void* ctxt) {
 void XMemDestroyDecompressionContext(void* ctxt) {
     return;
 }
+
+void* gfx_aligned_alloc(ulong a1, ulong a2, void*) {
+    return aligned_alloc(a2, a1);
+}
+
+void gfx_free(void* ptr, void*) {
+    free(ptr);
+}
+
+void* gfx_realloc(void* ptr, ulong size, void*) {
+    realloc(ptr, size);
+}
diff --git a/src/Minecraft.Client/platform/NX/Platform.h b/src/Minecraft.Client/platform/NX/Platform.h
index 817767cb..eaf8762c 100644
--- a/src/Minecraft.Client/platform/NX/Platform.h
+++ b/src/Minecraft.Client/platform/NX/Platform.h
@@ -6,6 +6,7 @@ This file contains all of the Switch implementations of Windows/XBOX functions
 
 */
 
+#include <cstdlib>
 #include <nn/os.h>
 
 typedef bool BOOL;
@@ -50,4 +51,8 @@ int TlsSetValue(unsigned int index, void* value);
 
 int OpenDir(const char*, int*);
 int ReadDir(int*, struct FSDirEntry*);  // TODO: what is FSDirEntry?
-int CloseDir(int*);
\ No newline at end of file
+int CloseDir(int*);
+
+void* gfx_aligned_alloc(ulong a1, ulong a2, void*);
+void gfx_free(void* ptr, void*);
+void* gfx_realloc(void* ptr, ulong, void*);
\ No newline at end of file
diff --git a/src/Minecraft.Client/renderer/C4JRender.h b/src/Minecraft.Client/renderer/C4JRender.h
index 536c600f..988c96ed 100644
--- a/src/Minecraft.Client/renderer/C4JRender.h
+++ b/src/Minecraft.Client/renderer/C4JRender.h
@@ -6,126 +6,130 @@ class D3DXIMAGE_INFO;
 
 class C4JRender {
 public:
+    C4JRender();
+
     enum eVertexType {};
     enum ePrimitiveType {};
     enum ePixelShaderType {};
     enum eTextureFormat {};
     enum eViewportType {};
 
-    virtual void Tick();
-    virtual void UpdateGamma(unsigned short);
-    virtual void MatrixMode(int);
-    virtual void MatrixSetIdentity();
-    virtual void MatrixTranslate(float, float, float);
-    virtual void MatrixRotate(float, float, float, float);
-    virtual void MatrixScale(float, float, float);
-    virtual void MatrixPerspective(float, float, float, float);
-    virtual void MatrixOrthogonal(float, float, float, float, float, float);
-    virtual void MatrixPop();
-    virtual void MatrixPush();
-    virtual void MatrixMult(float*);
-    virtual void MatrixGet(int);
-    virtual void Set_matrixDirty();
-    virtual void Initialise();
-    virtual void InitialiseContext();
-    virtual void StartFrame();
-    virtual void vtbl_7101130608_func_17();
-    virtual void vtbl_7101130608_func_18();
-    virtual void vtbl_7101130608_func_19();
-    virtual void Present();
-    virtual void Clear(int);
-    virtual void SetClearColour(const float*);
-    virtual void vtbl_7101130608_func_23();
-    virtual bool IsWidescreen();
-    virtual bool IsHiDef();
-    virtual void vtbl_7101130608_func_26();
-    virtual void CaptureThumbnail(ImageFileBuffer*);
-    virtual void CaptureScreen(ImageFileBuffer*, _XSOCIAL_PREVIEWIMAGE*);
-    virtual void BeginConditionalSurvey(int);
-    virtual void EndConditionalSurvey();
-    virtual void BeginConditionalRendering(int);
-    virtual void EndConditionalRendering();
-    virtual void BeginOrderIndependentAlpha();
-    virtual void EndOrderIndependentAlpha();
-    virtual void vtbl_7101130608_func_35();
-    virtual void vtbl_7101130608_func_36();
+    virtual void Tick() = 0;
+    virtual void UpdateGamma(unsigned short) = 0;
+    virtual void MatrixMode(int) = 0;
+    virtual void MatrixSetIdentity() = 0;
+    virtual void MatrixTranslate(float, float, float) = 0;
+    virtual void MatrixRotate(float, float, float, float) = 0;
+    virtual void MatrixScale(float, float, float) = 0;
+    virtual void MatrixPerspective(float, float, float, float) = 0;
+    virtual void MatrixOrthogonal(float, float, float, float, float, float) = 0;
+    virtual void MatrixPop() = 0;
+    virtual void MatrixPush() = 0;
+    virtual void MatrixMult(float*) = 0;
+    virtual void MatrixGet(int) = 0;
+    virtual void Set_matrixDirty() = 0;
+    virtual void Initialise() = 0;
+    virtual void InitialiseContext() = 0;
+    virtual void StartFrame() = 0;
+    virtual void vtbl_7101130608_func_17() = 0;
+    virtual void vtbl_7101130608_func_18() = 0;
+    virtual void vtbl_7101130608_func_19() = 0;
+    virtual void Present() = 0;
+    virtual void Clear(int) = 0;
+    virtual void SetClearColour(const float*) = 0;
+    virtual void vtbl_7101130608_func_23() = 0;
+    virtual bool IsWidescreen() = 0;
+    virtual bool IsHiDef() = 0;
+    virtual void vtbl_7101130608_func_26() = 0;
+    virtual void CaptureThumbnail(ImageFileBuffer*) = 0;
+    virtual void CaptureScreen(ImageFileBuffer*, _XSOCIAL_PREVIEWIMAGE*) = 0;
+    virtual void BeginConditionalSurvey(int) = 0;
+    virtual void EndConditionalSurvey() = 0;
+    virtual void BeginConditionalRendering(int) = 0;
+    virtual void EndConditionalRendering() = 0;
+    virtual void BeginOrderIndependentAlpha() = 0;
+    virtual void EndOrderIndependentAlpha() = 0;
+    virtual void vtbl_7101130608_func_35() = 0;
+    virtual void vtbl_7101130608_func_36() = 0;
     virtual void DrawVertices(C4JRender::ePrimitiveType, int, void*, C4JRender::eVertexType,
-                              C4JRender::ePixelShaderType, unsigned char*);
-    virtual void CBuffLockStaticCreations();
-    virtual void CBuffCreate(int);
-    virtual void CBuffDelete(int, int);
-    virtual void CBuffStart(int, bool);
-    virtual void CBuffClear(int);
-    virtual void CBuffSize(int);
-    virtual void CBuffEnd();
-    virtual void CBuffCall(int, bool, unsigned char);
-    virtual void CBuffTick();
-    virtual void CBuffDeferredModeStart();
-    virtual void CBuffDeferredModeEnd();
-    virtual void GetMaxTextures();
-    virtual void TextureCreate();
-    virtual void TextureFree(int);
-    virtual void TextureBind(int);
-    virtual void TextureBind(int, int);
-    virtual void TextureBindMask(int);
-    virtual void TextureBindVertex(int);
-    virtual void TextureSetTextureLevels(int);
-    virtual void TextureGetTextureLevels();
-    virtual void TextureData(int, int, void*, int, C4JRender::eTextureFormat);
-    virtual void TextureDataUpdate(int, int, int, int, void*, int);
-    virtual void TextureSetParam(int, int);
-    virtual void TextureDynamicUpdateStart();
-    virtual void TextureDynamicUpdateEnd();
-    virtual void LoadTextureData(const char*, D3DXIMAGE_INFO*, int**);
-    virtual void LoadTextureData(unsigned char*, unsigned int, D3DXIMAGE_INFO*, int**);
-    virtual void vtbl_7101130608_func_65();
-    virtual void vtbl_7101130608_func_66();
-    virtual void vtbl_7101130608_func_67();
-    virtual void StateSetColour(float, float, float, float);
-    virtual void StateSetColourAdd(float, float, float, float);
-    virtual void StateSetTexColour(int, float, float, float, float);
-    virtual void StateSetDepthMask(bool);
-    virtual void StateSetBlendEnable(bool);
-    virtual void StateSetBlendFunc(int, int);
-    virtual void StateSetBlendFactor(unsigned int);
-    virtual void StateSetAlphaFunc(int, float);
-    virtual void StateSetDepthFunc(int);
-    virtual void StateSetFaceCull(bool);
-    virtual void StateSetFaceCullCW(bool);
-    virtual void StateSetLineWidth(float);
-    virtual void StateSetWriteEnable(bool, bool, bool, bool);
-    virtual void StateSetDepthTestEnable(bool);
-    virtual void StateSetAlphaTestEnable(bool);
-    virtual void StateSetDepthSlopeAndBias(float, float);
-    virtual void StateSetFogEnable(bool);
-    virtual void StateSetFogMode(int);
-    virtual void StateSetFogNearDistance(float);
-    virtual void StateSetFogFarDistance(float);
-    virtual void StateSetFogDensity(float);
-    virtual void StateSetFogColour(float, float, float);
-    virtual void StateSetLightingEnable(bool);
-    virtual void StateSetVertexTextureUV(float, float);
-    virtual void StateSetTextureScaleUI(float, float, float, float);
-    virtual void StateSetScalingGridUI(float, float, float, float, float, float, float, float, float, float);
-    virtual void StateSetLightColour(int, float, float, float);
-    virtual void StateSetLightAmbientColour(float, float, float);
-    virtual void StateSetLightDirection(int, float, float, float);
-    virtual void StateSetLightEnable(int, bool);
-    virtual void StateSetViewport(C4JRender::eViewportType);
-    virtual void StateGetScissorRect(unsigned int&, unsigned int&, unsigned int&, unsigned int&);
-    virtual void StateSetScissorRect(unsigned int, unsigned int, unsigned int, unsigned int);
-    virtual void StateSetEnableViewportClipPlanes(bool);
-    virtual void StateSetTexGenCol(int, float, float, float, float, bool);
-    virtual void StateSetStencil(int, unsigned char, unsigned char, unsigned char);
-    virtual void StateSetForceLOD(int);
-    virtual void StateSetLerpColour(float, float, float, float);
-    virtual void SetLayeredColour(int, float, float, float);
-    virtual void SetLayeredParam(int, int, float, float);
-    virtual void SetLayeredTextureSize(int, int);
-    virtual void StateSetBoneMatrixData(int);
-    virtual void StateSetBoneMatrixNull(int);
-    virtual void GetNumCommandBufferVertsDrawnLastFrame();
-    virtual void GetNumVertsInCommandBuffer(int);
-    virtual void BeginEvent(const wchar_t*);
-    virtual void EndEvent();
+                              C4JRender::ePixelShaderType, unsigned char*)
+        = 0;
+    virtual void CBuffLockStaticCreations() = 0;
+    virtual void CBuffCreate(int) = 0;
+    virtual void CBuffDelete(int, int) = 0;
+    virtual void CBuffStart(int, bool) = 0;
+    virtual void CBuffClear(int) = 0;
+    virtual void CBuffSize(int) = 0;
+    virtual void CBuffEnd() = 0;
+    virtual void CBuffCall(int, bool, unsigned char) = 0;
+    virtual void CBuffTick() = 0;
+    virtual void CBuffDeferredModeStart() = 0;
+    virtual void CBuffDeferredModeEnd() = 0;
+    virtual void GetMaxTextures() = 0;
+    virtual int TextureCreate() = 0;
+    virtual void TextureFree(int) = 0;
+    virtual void TextureBind(int) = 0;
+    virtual void TextureBind(int, int) = 0;
+    virtual void TextureBindMask(int) = 0;
+    virtual void TextureBindVertex(int) = 0;
+    virtual void TextureSetTextureLevels(int) = 0;
+    virtual void TextureGetTextureLevels() = 0;
+    virtual void TextureData(int, int, void*, int, C4JRender::eTextureFormat) = 0;
+    virtual void TextureDataUpdate(int, int, int, int, void*, int) = 0;
+    virtual void TextureSetParam(int, int) = 0;
+    virtual void TextureDynamicUpdateStart() = 0;
+    virtual void TextureDynamicUpdateEnd() = 0;
+    virtual void LoadTextureData(const char*, D3DXIMAGE_INFO*, int**) = 0;
+    virtual void LoadTextureData(unsigned char*, unsigned int, D3DXIMAGE_INFO*, int**) = 0;
+    virtual void vtbl_7101130608_func_65() = 0;
+    virtual void vtbl_7101130608_func_66() = 0;
+    virtual void vtbl_7101130608_func_67() = 0;
+    virtual void StateSetColour(float, float, float, float) = 0;
+    virtual void StateSetColourAdd(float, float, float, float) = 0;
+    virtual void StateSetTexColour(int, float, float, float, float) = 0;
+    virtual void StateSetDepthMask(bool) = 0;
+    virtual void StateSetBlendEnable(bool) = 0;
+    virtual void StateSetBlendFunc(int, int) = 0;
+    virtual void StateSetBlendFactor(unsigned int) = 0;
+    virtual void StateSetAlphaFunc(int, float) = 0;
+    virtual void StateSetDepthFunc(int) = 0;
+    virtual void StateSetFaceCull(bool) = 0;
+    virtual void StateSetFaceCullCW(bool) = 0;
+    virtual void StateSetLineWidth(float) = 0;
+    virtual void StateSetWriteEnable(bool, bool, bool, bool) = 0;
+    virtual void StateSetDepthTestEnable(bool) = 0;
+    virtual void StateSetAlphaTestEnable(bool) = 0;
+    virtual void StateSetDepthSlopeAndBias(float, float) = 0;
+    virtual void StateSetFogEnable(bool) = 0;
+    virtual void StateSetFogMode(int) = 0;
+    virtual void StateSetFogNearDistance(float) = 0;
+    virtual void StateSetFogFarDistance(float) = 0;
+    virtual void StateSetFogDensity(float) = 0;
+    virtual void StateSetFogColour(float, float, float) = 0;
+    virtual void StateSetLightingEnable(bool) = 0;
+    virtual void StateSetVertexTextureUV(float, float) = 0;
+    virtual void StateSetTextureScaleUI(float, float, float, float) = 0;
+    virtual void StateSetScalingGridUI(float, float, float, float, float, float, float, float, float, float)
+        = 0;
+    virtual void StateSetLightColour(int, float, float, float) = 0;
+    virtual void StateSetLightAmbientColour(float, float, float) = 0;
+    virtual void StateSetLightDirection(int, float, float, float) = 0;
+    virtual void StateSetLightEnable(int, bool) = 0;
+    virtual void StateSetViewport(C4JRender::eViewportType) = 0;
+    virtual void StateGetScissorRect(unsigned int&, unsigned int&, unsigned int&, unsigned int&) = 0;
+    virtual void StateSetScissorRect(unsigned int, unsigned int, unsigned int, unsigned int) = 0;
+    virtual void StateSetEnableViewportClipPlanes(bool) = 0;
+    virtual void StateSetTexGenCol(int, float, float, float, float, bool) = 0;
+    virtual void StateSetStencil(int, unsigned char, unsigned char, unsigned char) = 0;
+    virtual void StateSetForceLOD(int) = 0;
+    virtual void StateSetLerpColour(float, float, float, float) = 0;
+    virtual void SetLayeredColour(int, float, float, float) = 0;
+    virtual void SetLayeredParam(int, int, float, float) = 0;
+    virtual void SetLayeredTextureSize(int, int) = 0;
+    virtual void StateSetBoneMatrixData(int) = 0;
+    virtual void StateSetBoneMatrixNull(int) = 0;
+    virtual void GetNumCommandBufferVertsDrawnLastFrame() = 0;
+    virtual void GetNumVertsInCommandBuffer(int) = 0;
+    virtual void BeginEvent(const wchar_t*) = 0;
+    virtual void EndEvent() = 0;
 };
diff --git a/src/Minecraft.Client/renderer/Renderer.cpp b/src/Minecraft.Client/renderer/Renderer.cpp
index 0ba5b5aa..1d5e949f 100644
--- a/src/Minecraft.Client/renderer/Renderer.cpp
+++ b/src/Minecraft.Client/renderer/Renderer.cpp
@@ -1,2 +1,394 @@
+#include "nn/os/os_MutexTypes.h"
+#include "Minecraft.Client/platform/NX/Platform.h"
+#include "Minecraft.Client/renderer/C4JRender.h"
 #include "Minecraft.Client/renderer/Renderer.h"
-#include "png.h"
+#include "UnknownRendererClasses.h"
+#include "nn/diag.h"
+#include "nn/vi.h"
+#include "nv.h"
+#include "nvn/nvn.h"
+#include "nvn/nvn_FuncPtrBase.h"
+#include "nvn/nvn_FuncPtrImpl.h"
+#include "nvn/nvn_FuncPtrInline.h"
+#include <cstdint>
+#include <cstdlib>
+
+__thread Renderer::Context* sContext;
+unsigned int textureWidths[6] = {1920, 1280, 512, 256, 128, 64};
+unsigned int textureHeights[6] = {1080, 720, 512, 256, 128, 64};
+nn::os::MutexType someRendererMutex;
+
+Renderer::Context::Context(Renderer*, bool a2) {
+    this->filler[0] = a2;
+}
+
+Renderer::Renderer() : C4JRender() {
+    this->qword3CD88 = nullptr;
+    this->qword3CD90 = nullptr;
+    this->qword3CD98 = nullptr;
+
+    Renderer::sInstance = this;
+}
+
+// NON_MATCHING: inline the tls offset getter, could be some compiler flag
+void Renderer::InitialiseContext(bool idk) {
+    sContext = new Renderer::Context(this, idk);
+}
+
+void Renderer::SetupMemoryPools() {
+    NVNmemoryPoolBuilder builder;
+    nvnMemoryPoolBuilderSetDefaults(&builder);
+    nvnMemoryPoolBuilderSetDevice(&builder, this->mNVNdevice);
+
+    nvnMemoryPoolBuilderSetFlags(&builder,
+                                 NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED | NVN_MEMORY_POOL_FLAGS_GPU_CACHED);
+    this->mPoolMemory = memalign(0x1000, 0x20000000);
+    nvnMemoryPoolBuilderSetStorage(&builder, this->mPoolMemory, 0x20000000);
+    nvnMemoryPoolInitialize(&this->mNVNmemoryPool[0], &builder);
+    this->mIdk = 0;  // have no idea what are those
+
+    nvnMemoryPoolBuilderSetFlags(&builder, NVN_MEMORY_POOL_FLAGS_CPU_NO_ACCESS
+                                               | NVN_MEMORY_POOL_FLAGS_GPU_CACHED
+                                               | NVN_MEMORY_POOL_FLAGS_COMPRESSIBLE);
+    this->mPoolMemory2 = memalign(0x1000, 0x4000000);
+    nvnMemoryPoolBuilderSetStorage(&builder, this->mPoolMemory2, 0x4000000);
+    nvnMemoryPoolInitialize(&this->mNVNmemoryPool[1], &builder);
+    this->mIdk2 = 0;
+
+    nvnMemoryPoolBuilderSetFlags(&builder, NVN_MEMORY_POOL_FLAGS_SHADER_CODE
+                                               | NVN_MEMORY_POOL_FLAGS_GPU_CACHED
+                                               | NVN_MEMORY_POOL_FLAGS_CPU_UNCACHED);
+    this->mPoolMemory3 = memalign(0x1000, 0x100000);
+    nvnMemoryPoolBuilderSetStorage(&builder, this->mPoolMemory3, 0x100000);
+    nvnMemoryPoolInitialize(&this->mNVNmemoryPool[2], &builder);
+    this->mIdk3 = 0;
+}
+
+typedef float mat4x4[4][4];
+
+void Renderer::Initialise() {
+    this->Initialise(0);
+}
+
+// thanks to Fuzzy2319 for spotting last 2 fixes
+void Renderer::Initialise(bool) {
+    nv::SetGraphicsAllocator(gfx_aligned_alloc, gfx_free, gfx_realloc, nullptr);
+    nv::InitializeGraphics(malloc(0x800000), 0x800000);
+    nv::SetGraphicsDevtoolsAllocator(gfx_aligned_alloc, gfx_free, gfx_realloc, nullptr);
+    nn::vi::Initialize();
+
+    nn::Result result = nn::vi::OpenDefaultDisplay(&this->mDisplay);
+    if (!result.IsSuccess())
+        nn::diag::detail::OnAssertionFailure((nn::diag::AssertionType)2, "", "", "", 0);
+
+    this->dword28E8 = 1;
+    this->dword28EC = 1;
+    this->mTextureSizesFirst[0] = 1920;
+    this->mTextureSizesFirst[1] = 1280;
+    this->mTextureSizesSecond[0] = 1080;
+    this->mTextureSizesSecond[1] = 720;
+
+    result = nn::vi::CreateLayer(&this->mLayer, this->mDisplay);
+    if (!result.IsSuccess())
+        nn::diag::detail::OnAssertionFailure((nn::diag::AssertionType)2, "", "", "", 0);
+
+    result = nn::vi::SetLayerScalingMode(this->mLayer, nn::vi::FitLayer);
+    if (!result.IsSuccess())
+        nn::diag::detail::OnAssertionFailure((nn::diag::AssertionType)2, "", "", "", 0);
+
+    result = nn::vi::GetNativeWindow(&this->mWindow, this->mLayer);
+    pfnc_nvnDeviceGetProcAddress
+        = (PFNNVNDEVICEGETPROCADDRESSPROC)nvnBootstrapLoader("nvnDeviceGetProcAddress");
+    nvnLoadCProcs(nullptr, pfnc_nvnDeviceGetProcAddress);
+
+    NVNdeviceBuilder deviceBuilder;
+    nvnDeviceBuilderSetDefaults(&deviceBuilder);
+    nvnDeviceBuilderSetFlags(&deviceBuilder, 0);  // same as here
+
+    this->mNVNdevice = (NVNdevice*)operator new(0x3000);  // hmmm
+    nvnDeviceInitialize(this->mNVNdevice, &deviceBuilder);
+    nvnLoadCProcs(this->mNVNdevice, pfnc_nvnDeviceGetProcAddress);
+
+    int API_MAJOR_VERSION, API_MINOR_VERSION;
+    nvnDeviceGetInteger(nullptr, NVN_DEVICE_INFO_API_MAJOR_VERSION, &API_MAJOR_VERSION);
+    nvnDeviceGetInteger(nullptr, NVN_DEVICE_INFO_API_MINOR_VERSION, &API_MINOR_VERSION);
+
+    nvnDeviceSetWindowOriginMode(this->mNVNdevice,
+                                 NVN_WINDOW_ORIGIN_MODE_UPPER_LEFT);  // this is not how call looks iirc,
+                                                                      // after tools/check I will confirm
+
+    nvnSyncInitialize(&this->mNVNsync[0], this->mNVNdevice);
+    nvnSyncInitialize(&this->mNVNsync[1], this->mNVNdevice);
+    nvnSyncInitialize(&this->mNVNsync[2], this->mNVNdevice);
+
+    SetupMemoryPools();
+
+    NVNqueueBuilder queueBuilder1;
+    nvnQueueBuilderSetDevice(&queueBuilder1, this->mNVNdevice);
+    nvnQueueBuilderSetDefaults(&queueBuilder1);
+    nvnQueueBuilderSetComputeMemorySize(&queueBuilder1, 0);
+
+    int QUEUE_COMMAND_MEMORY_MIN_SIZE = 0;
+    nvnDeviceGetInteger(this->mNVNdevice, NVN_DEVICE_INFO_QUEUE_COMMAND_MEMORY_MIN_SIZE,
+                        &QUEUE_COMMAND_MEMORY_MIN_SIZE);
+    nvnQueueBuilderSetCommandMemorySize(&queueBuilder1, QUEUE_COMMAND_MEMORY_MIN_SIZE);
+    nvnQueueBuilderSetCommandFlushThreshold(&queueBuilder1, QUEUE_COMMAND_MEMORY_MIN_SIZE);
+    size_t queueMemorySize = nvnQueueBuilderGetQueueMemorySize(&queueBuilder1);
+    if ((queueMemorySize & 0xFFF) != 0)
+        nn::diag::detail::OnAssertionFailure((nn::diag::AssertionType)2, "", "", "", 0);
+    this->mQueueMemory = memalign(0x1000, queueMemorySize);
+    nvnQueueBuilderSetQueueMemory(&queueBuilder1, this->mQueueMemory, queueMemorySize);
+    if (!nvnQueueInitialize(&this->mNVNqueue, &queueBuilder1))
+        nn::diag::detail::OnAssertionFailure((nn::diag::AssertionType)2, "", "", "", 0);
+
+    nvnCommandBufferInitialize(&this->mNVNcommandBuffer, this->mNVNdevice);
+    this->qword21E8 = this->sub_7100799078(0, 0x400000, 4);
+    this->qword21F8 = memalign(8, 0x800);
+    this->dword21F0 = 0;
+
+    nvnTextureBuilderSetDevice(&this->mNVNtextureBuilder, this->mNVNdevice);
+    nvnTextureBuilderSetDefaults(&this->mNVNtextureBuilder);
+    nvnTextureBuilderSetFlags(&this->mNVNtextureBuilder,
+                              NVN_TEXTURE_FLAGS_COMPRESSIBLE | NVN_TEXTURE_FLAGS_DISPLAY);
+    nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, this->mTextureSizesFirst[0],
+                               this->mTextureSizesSecond[0]);
+    nvnTextureBuilderSetTarget(&this->mNVNtextureBuilder, NVN_TEXTURE_TARGET_2D);
+    nvnTextureBuilderSetFormat(&this->mNVNtextureBuilder, NVN_FORMAT_RGBA8);
+    this->mRGBA8__TextureStorageSize = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+    this->mRGBA8__TextureStorageAlignment = nvnTextureBuilderGetStorageAlignment(&this->mNVNtextureBuilder);
+
+    nvnTextureBuilderSetDefaults(&this->mNVNtextureBuilder);
+    nvnTextureBuilderSetFlags(&this->mNVNtextureBuilder, NVN_TEXTURE_FLAGS_COMPRESSIBLE);
+    nvnTextureBuilderSetTarget(&this->mNVNtextureBuilder, NVN_TEXTURE_TARGET_2D);
+    nvnTextureBuilderSetFormat(&this->mNVNtextureBuilder, NVN_FORMAT_DEPTH24_STENCIL8);
+    nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, this->mTextureSizesFirst[0],
+                               this->mTextureSizesSecond[0]);
+    this->mDEPTH24_STENCIL8__TextureStorageSize = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+    this->mDEPTH24_STENCIL8__TextureStorageAlignment
+        = nvnTextureBuilderGetStorageAlignment(&this->mNVNtextureBuilder);
+
+    nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, this->mTextureSizesFirst[1],
+                               this->mTextureSizesSecond[1]);
+    this->mDEPTH24_STENCIL8__HDTextureStorageSize
+        = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+    this->mDEPTH24_STENCIL8__HDTextureStorageAlignment = this->sub_7100799078(
+        1, 3 * this->mRGBA8__TextureStorageSize + this->mDEPTH24_STENCIL8__TextureStorageSize,
+        this->mRGBA8__TextureStorageAlignment);
+
+    nvnTextureBuilderSetFormat(&this->mNVNtextureBuilder, NVN_FORMAT_RGBA16F);
+    nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, this->mTextureSizesFirst[0],
+                               this->mTextureSizesSecond[0]);
+    this->mRGBA16F__TextureStorageSize = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+    this->mRGBA16F__TextureStorageAlignment = nvnTextureBuilderGetStorageAlignment(&this->mNVNtextureBuilder);
+
+    nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, this->mTextureSizesFirst[1],
+                               this->mTextureSizesSecond[1]);
+    this->mRGBA16F__HDTextureStorageSize = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+    this->mRGBA16F__HDTextureStorageAlignment = this->sub_7100799078(1, this->mRGBA16F__TextureStorageSize,
+                                                                     this->mRGBA16F__TextureStorageAlignment);
+
+    nvnTextureBuilderSetFormat(&this->mNVNtextureBuilder, NVN_FORMAT_RGBA8);
+
+    for (int i = 0; i < 6; i++) {
+        nvnTextureBuilderSetSize2D(&this->mNVNtextureBuilder, textureWidths[i], textureHeights[i]);
+        this->mTextureStorageSizes[i] = nvnTextureBuilderGetStorageSize(&this->mNVNtextureBuilder);
+        this->mTextureStorageAlignments[i] = nvnTextureBuilderGetStorageAlignment(&this->mNVNtextureBuilder);
+
+        if (i == 1) {
+            this->mIdkReally[i] = this->mIdkReally[0];
+            continue;
+        }
+
+        this->mIdkReally[i]
+            = this->sub_7100799078(1, this->mTextureStorageSizes[i], this->mTextureStorageAlignments[i]);
+    }
+
+    NVNbufferBuilder bufferBuilder1;
+    nvnBufferBuilderSetDevice(&bufferBuilder1, this->mNVNdevice);
+    nvnBufferBuilderSetDefaults(&bufferBuilder1);
+
+    size_t offset = this->sub_7100799078(0, 0x4000, 1);
+    nvnBufferBuilderSetStorage(&bufferBuilder1, this->getNVNMemoryPoolByIndex(0), offset, 0x4000);
+    nvnBufferInitialize(&this->mBuffers[0], &bufferBuilder1);
+
+    offset = this->sub_7100799078(0, (4 * textureWidths[0] * textureHeights[0]), 1);
+    nvnBufferBuilderSetStorage(&bufferBuilder1, this->getNVNMemoryPoolByIndex(0), offset,
+                               4 * textureWidths[0] * textureHeights[0]);
+    nvnBufferInitialize(&this->mBuffers[1], &bufferBuilder1);
+
+    nvnDeviceGetInteger(this->mNVNdevice, NVN_DEVICE_INFO_RESERVED_TEXTURE_DESCRIPTORS,
+                        &this->RESERVED_TEXTURE_DESCRIPTORS);
+    nvnDeviceGetInteger(this->mNVNdevice, NVN_DEVICE_INFO_RESERVED_SAMPLER_DESCRIPTORS,
+                        &this->RESERVED_SAMPLER_DESCRIPTORS);
+
+    int HD_TYPE = this->RESERVED_TEXTURE_DESCRIPTORS + 1035;  // why????
+    int HD_TYPE_1 = this->RESERVED_SAMPLER_DESCRIPTORS + 64;
+
+    this->dword2250 = 0;
+    this->HD_RESERVED_TEXTURE_DESCRIPTORS = HD_TYPE;
+    this->HD_RESERVED_SAMPLER_DESCRIPTORS = HD_TYPE_1;
+
+    int DESCRIPTOR_SIZE;
+    nvnDeviceGetInteger(this->mNVNdevice, NVN_DEVICE_INFO_TEXTURE_DESCRIPTOR_SIZE, &DESCRIPTOR_SIZE);
+    offset
+        = this->sub_7100799078(0, DESCRIPTOR_SIZE * this->HD_RESERVED_TEXTURE_DESCRIPTORS, DESCRIPTOR_SIZE);
+    nvnTexturePoolInitialize(&this->mNVNtexturePool, getNVNMemoryPoolByIndex(0), offset,
+                             this->HD_RESERVED_TEXTURE_DESCRIPTORS);
+
+    nvnDeviceGetInteger(this->mNVNdevice, NVN_DEVICE_INFO_SAMPLER_DESCRIPTOR_SIZE, &DESCRIPTOR_SIZE);
+    offset
+        = this->sub_7100799078(0, DESCRIPTOR_SIZE * this->HD_RESERVED_SAMPLER_DESCRIPTORS, DESCRIPTOR_SIZE);
+    nvnSamplerPoolInitialize(&this->mNVNsamplerPool, getNVNMemoryPoolByIndex(0), offset,
+                             this->HD_RESERVED_SAMPLER_DESCRIPTORS);
+
+    this->qword26E0 = 0;
+    this->qword26E8 = 0;
+    this->qword26F0 = 0;
+    this->qword26F8 = 0;
+    this->qword2700 = 0;
+    this->mNVNwindow = nullptr;
+    this->qword2758 = 0;
+    this->qword2760 = 0;
+    this->qword2798 = 0;
+    this->qword27A0 = 0;
+    this->qword27A8 = 0;
+    this->qword27B0 = 0;
+    this->qword27B8 = 0;
+    this->qword27C0 = 0;
+
+    nvnWindowBuilderSetDefaults(&this->mNVNwindowBuilder);
+    nvnWindowBuilderSetDevice(&this->mNVNwindowBuilder, this->mNVNdevice);
+    nvnWindowBuilderSetNativeWindow(&this->mNVNwindowBuilder, this->mWindow);
+
+    this->sub_7100796C74();
+
+    this->qword2598 = this->sub_7100799078(0, 0x4000000, 0x100);
+
+    NVNbufferBuilder bufferBuilder;
+    nvnBufferBuilderSetDefaults(&bufferBuilder);
+    nvnBufferBuilderSetDevice(&bufferBuilder, this->mNVNdevice);
+    nvnBufferBuilderSetStorage(&bufferBuilder, getNVNMemoryPoolByIndex(0), this->qword2598, 0x4000000);
+    nvnBufferInitialize(&this->mNVNbuffer, &bufferBuilder);
+
+    this->qword25A0 = (void*)256;
+    this->dword25A8 = 0;
+    this->mBufferMap = (float*)nvnBufferMap(&this->mNVNbuffer);
+    this->mNVNbufferAddr = nvnBufferGetAddress(&this->mNVNbuffer);
+
+    mat4x4& matrix1 = *reinterpret_cast<mat4x4*>(this->mBufferMap);
+    memset(matrix1, 0, sizeof(matrix1));
+    matrix1[0][0] = 1.0f;
+    matrix1[1][1] = 1.0f;
+    matrix1[2][2] = 1.0f;
+    matrix1[3][3] = 1.0f;
+
+    mat4x4& matrix2 = *reinterpret_cast<mat4x4*>(this->mBufferMap + 0x800000);
+    memset(matrix2, 0, sizeof(matrix2));
+    matrix2[0][0] = 1.0f;
+    matrix2[1][1] = 1.0f;
+    matrix2[2][2] = 1.0f;
+    matrix2[3][3] = 1.0f;
+
+    this->qword25F0 = this->sub_7100799078(0, 0xA00000, 4);
+    nvnBufferBuilderSetStorage(&bufferBuilder, getNVNMemoryPoolByIndex(0), this->qword25F0, 0xA00000);
+    nvnBufferInitialize(&this->mNVNbuffer2, &bufferBuilder);
+    this->qword25F8 = 0LL;
+    this->dword2600 = 0;
+    this->mBufferMap2 = nvnBufferMap(&this->mNVNbuffer2);
+    this->mNVNbufferAddr2 = nvnBufferGetAddress(&this->mNVNbuffer2);
+
+    this->qword2648 = this->sub_7100799078(0, 0x800000, 16);
+    nvnBufferBuilderSetStorage(&bufferBuilder, getNVNMemoryPoolByIndex(0), this->qword2648, 0x800000);
+    nvnBufferInitialize(&this->mNVNbuffer3, &bufferBuilder);
+    this->qword2650 = 0LL;
+    this->dword2658 = 0;
+    this->mBufferMap3 = (void*)nvnBufferMap(&this->mNVNbuffer3);
+    this->mNVNbufferAddr3 = nvnBufferGetAddress(&this->mNVNbuffer3);
+
+    this->InitialiseContext(true);
+
+    this->mSomethingTexturePtrs[0] = (void*)operator new[](0x1000000uLL);
+    this->mSomethingTexturePtrs[1] = (void*)operator new[](0x1F400uLL);
+    this->mSomethingTexturePtrs[2] = (void*)operator new[](0xFA000uLL);
+    this->mSomethingTexturePtrs[3] = (void*)operator new[](0xFA00uLL);
+    this->mSomethingTexturePtrs[4] = (void*)operator new[](0x3E80uLL);
+    this->mSomethingTexturePtrs[5] = (void*)operator new[](0xFA00uLL);
+    this->mSomethingTexturePtrs[6] = (void*)operator new[](0x3E80uLL);
+    memset(this->mSomethingTexturePtrs[0], 255, 0x1000000uLL);
+    memset(this->mSomethingTexturePtrs[1], 0, 0x1F400uLL);
+    memset(this->mSomethingTexturePtrs[3], 0, 0xFA00uLL);
+    memset(this->mSomethingTexturePtrs[5], 0, 0xFA00uLL);
+    memset(this->mSomethingTexturePtrs[4], 0, 0x3E80uLL);
+    memset(this->mSomethingTexturePtrs[6], 0, 0x3E80uLL);
+    // COULD BE THAT THIS MISSMATCHES, ORDER OF MEMSETS
+
+    this->elo1 = 0;
+    this->elo2 = 0;
+    this->word3CE00 = 0;
+
+    this->qword3CDC0 = psInstance->sub_7100799078(0, 0x8000000, 4);
+    this->class_71007B7E78_1 = new class_71007B7E78(this->qword3CDC0, 0x8000000);
+
+    this->qword3CDC8 = psInstance->sub_7100799078(0, 0x8000000, 1024);
+    this->class_71007B7E78_2 = new class_71007B7E78(this->qword3CDC8, 0x8000000);
+
+    this->LoadShaders();
+    this->SetupShaders();
+
+    float colour[4] = {};
+    this->SetClearColour(colour);
+
+    memset(this->someData, 0, sizeof(this->someData));
+
+    nn::os::InitializeMutex(&this->mMutex1, 1, 0);
+    nn::os::InitializeMutex(&someRendererMutex, 1, 0);
+    nn::os::InitializeMutex(&this->mMutex2, 1, 0);
+    nn::os::InitializeMutex(&this->mMutex3, 1, 0);
+
+    this->mTextureID_1 = this->TextureCreate();  // could be that this is done as arg for below
+    this->TextureBind(this->mTextureID_1);
+
+    char someString[1024];
+    memset(someString, 255, sizeof(someString));
+    this->TextureData(16, 16, someString, 0, (C4JRender::eTextureFormat)0);
+
+    this->word2994 = 10922;
+    this->dword2998 = 0;
+    this->byte299C = 0;
+
+    this->bool3C9E0 = 1;
+    this->dword3C9E4 = 0;
+
+    this->StateSetVertexTextureUV(0.0f, 0.0f);
+    this->StateSetTextureScaleUI(1.0f, 1.0f, 0.0f, 0.0f);
+    this->StateSetLerpColour(0.0f, 0.0f, 0.0f, 0.0f);
+    this->StateSetFogColour(0.0f, 0.0f, 0.0f);
+    this->StateSetFogEnable(false);
+
+    int src[4] = {0x3F800000, 0x3F800000, 0x3F800000, 0x3F800000};
+    memcpy(&this->char3CE04, src, 0x10);
+    memset(&this->char3CE44, 0, 0x10);
+    memcpy(&this->char3CE54, src, 0x10);
+    memcpy(&this->char3CE64, src, 0x10);
+    memcpy(&this->char3CE74, src, 0x10);
+    memcpy(&this->char3CE84, src, 0x10);
+    this->byte3CE94 = 1;
+    memset(&this->dupa, 0, 0x70);
+    memset(&this->cipa, 0, 0x10);
+
+    this->bool3CF18 = 1;
+
+    this->StateSetVertexTextureUV(0.0f, 0.0f);
+    this->dword29C0 = -1;
+    this->dword29C4 = -1;
+    this->byte29CC = 0;
+    this->elo = 0;
+    this->elo22 = 0;
+
+    nvnWindowSetCrop(this->mNVNwindow, 0, 0, mTextureSizesFirst[this->dword28E8],
+                     mTextureSizesSecond[this->dword28E8]);
+}
+
+void Renderer::InitialiseContext() {
+    this->InitialiseContext(false);
+}
\ No newline at end of file
diff --git a/src/Minecraft.Client/renderer/Renderer.h b/src/Minecraft.Client/renderer/Renderer.h
index 7a5868be..4906305b 100644
--- a/src/Minecraft.Client/renderer/Renderer.h
+++ b/src/Minecraft.Client/renderer/Renderer.h
@@ -1,17 +1,53 @@
 #pragma once
 
+#include "nn/os/os_MutexTypes.h"
 #include "Minecraft.Client/renderer/C4JRender.h"
+#include "nn/vi.h"
+#include "nvn/nvn.h"
+#include <cstddef>
+#include <cstdint>
+#include <unordered_map>
 
 class _XSOCIAL_PREVIEWIMAGE;
 class ImageFileBuffer;
 class D3DXIMAGE_INFO;
+class class_71007B7E78;
+
+class SomeData {  // this is probably class but who knows...
+public:
+    SomeData();
+
+    void* data[29];
+};
 
 class Renderer : public C4JRender {
 public:
+    class Context {
+    public:
+        Context(Renderer*, bool);
+
+        char filler[0x1F30];
+    };
+
     Renderer();
 
     static Renderer* sInstance;
 
+private:
+    static Renderer* psInstance;
+
+public:
+    size_t sub_7100799078(int wchichOne, size_t size,
+                          size_t alignment);  // gotta decomp it then figure out name for that, it's some
+                                              // offset "generator" shit
+    void sub_7100796C74();                    // setup some texture stuff
+    NVNmemoryPool* getNVNMemoryPoolByIndex(unsigned int index) { return &this->mNVNmemoryPool[index]; }
+    void SetupMemoryPools();  // guessed name
+    void InitialiseContext(bool);
+    void LoadShaders();
+    void SetupShaders();
+    void Initialise(bool);
+
     virtual void Tick();
     virtual void UpdateGamma(unsigned short);
     virtual void MatrixMode(int);
@@ -26,6 +62,7 @@ class Renderer : public C4JRender {
     virtual void MatrixMult(float*);
     virtual void MatrixGet(int);
     virtual void Set_matrixDirty();
+    // unused params were probably used in Xbox One
     virtual void Initialise();
     virtual void InitialiseContext();
     virtual void StartFrame();
@@ -63,7 +100,7 @@ class Renderer : public C4JRender {
     virtual void CBuffDeferredModeStart();
     virtual void CBuffDeferredModeEnd();
     virtual void GetMaxTextures();
-    virtual void TextureCreate();
+    virtual int TextureCreate();
     virtual void TextureFree(int);
     virtual void TextureBind(int);
     virtual void TextureBind(int, int);
@@ -128,4 +165,165 @@ class Renderer : public C4JRender {
     virtual void GetNumVertsInCommandBuffer(int);
     virtual void BeginEvent(const wchar_t*);
     virtual void EndEvent();
+
+    char gap8[16];
+    NVNdevice* mNVNdevice;
+    nn::vi::Display* mDisplay;
+    nn::vi::Layer* mLayer;
+    void* mWindow;
+    NVNqueue mNVNqueue;
+    void* mQueueMemory;
+    NVNsync mNVNsync[3];
+    NVNwindow* mNVNwindow;
+    NVNwindowBuilder mNVNwindowBuilder;
+    NVNcommandBuffer mNVNcommandBuffer;
+    size_t qword21E8;
+    int dword21F0;
+    char gap21F4[4];
+    void* qword21F8;
+    int RESERVED_TEXTURE_DESCRIPTORS;
+    int RESERVED_SAMPLER_DESCRIPTORS;
+    int HD_RESERVED_TEXTURE_DESCRIPTORS;  // those don't have to be HD, it's just guessing
+    int HD_RESERVED_SAMPLER_DESCRIPTORS;
+    NVNtexturePool mNVNtexturePool;
+    NVNsamplerPool mNVNsamplerPool;
+    int dword2250;
+    char gap2254[772];
+    NVNbuffer mNVNbuffer;
+    NVNbufferAddress mNVNbufferAddr;
+    float* mBufferMap;
+    size_t qword2598;
+    void* qword25A0;
+    int dword25A8;
+    int dword25AC;
+    NVNbuffer mNVNbuffer2;
+    NVNbufferAddress mNVNbufferAddr2;
+    void* mBufferMap2;
+    size_t qword25F0;
+    void* qword25F8;
+    int dword2600;
+    int dword2604;
+    NVNbuffer mNVNbuffer3;
+    NVNbufferAddress mNVNbufferAddr3;
+    void* mBufferMap3;
+    size_t qword2648;
+    void* qword2650;
+    int dword2658;
+    int dword265C;
+    NVNtextureBuilder mNVNtextureBuilder;
+    void* qword26E0;
+    void* qword26E8;
+    void* qword26F0;
+    void* qword26F8;
+    void* qword2700;
+    char gap2708[32];
+    size_t mRGBA8__TextureStorageSize;  // it seems that nvn names ptrs storage
+    size_t mRGBA8__TextureStorageAlignment;
+    size_t mDEPTH24_STENCIL8__TextureStorageSize;
+    size_t mDEPTH24_STENCIL8__HDTextureStorageSize;
+    size_t mDEPTH24_STENCIL8__TextureStorageAlignment;
+    size_t mDEPTH24_STENCIL8__HDTextureStorageAlignment;
+    void* qword2758;
+    void* qword2760;
+    size_t mRGBA16F__TextureStorageSize;
+    size_t mRGBA16F__HDTextureStorageSize;
+    size_t mRGBA16F__TextureStorageAlignment;
+    size_t mRGBA16F__HDTextureStorageAlignment;
+    char gap2788[16];
+    void* qword2798;
+    void* qword27A0;
+    void* qword27A8;
+    void* qword27B0;
+    void* qword27B8;
+    void* qword27C0;
+    size_t mTextureStorageSizes[6];
+    size_t mTextureStorageAlignments[6];
+    size_t mIdkReally[6];
+    char gap2858[48];
+    NVNbuffer
+        mBuffers[2];  // it could be that one is FHD one is HD, but until ik that let's keep them in array
+    int dword28E8;
+    int dword28EC;
+    NVNprogram* shaders1;
+    NVNprogram* shaders2;
+    NVNprogram* shaders3;
+    NVNprogram* shaders4;
+    NVNprogram* shaders5;
+    NVNprogram* shaders6;
+    NVNprogram* shaders7;
+    NVNprogram* shaders8;
+    NVNprogram* shaders9;
+    NVNprogram* shaders10;
+    NVNprogram* shaders11;
+    NVNprogram* shaders12;
+    NVNprogram* shaders13;
+    NVNprogram* shaders14;
+    char gap2960[48];
+    int mTextureID_1;
+    uint16_t word2994;
+    int dword2998;
+    char byte299C;
+    nn::os::MutexType mMutex1;
+    int dword29C0;
+    int dword29C4;
+    char gap29C8[4];
+    char byte29CC;
+    SomeData someData[1024];
+    int mTextureSizesFirst[2];
+    int mTextureSizesSecond[2];
+    // int mFHDTexture2DWidth;
+    // int mFHDTexture2DHeight;
+    // int mHDTexture2DWidth;
+    // int mHDTexture2DHeight;
+    bool bool3C9E0;
+    int dword3C9E4;
+    void* mSomethingTexturePtrs[7];
+    int elo1;
+    int elo2;
+    std::unordered_map<int, int> map;  // as for now it's impossible to track down complete type
+    NVNmemoryPool mNVNmemoryPool[3];
+    void* mPoolMemory;
+    void* mPoolMemory2;
+    void* mPoolMemory3;
+    void* mIdk;
+    void* mIdk2;
+    void* mIdk3;
+    class_71007B7E78* class_71007B7E78_1;
+    void* qword3CD88;
+    void* qword3CD90;
+    void* qword3CD98;
+    nn::os::MutexType mMutex2;
+    size_t qword3CDC0;
+    size_t qword3CDC8;
+    nn::os::MutexType mMutex3;
+    class_71007B7E78* class_71007B7E78_2;
+    char gap3CDF8[8];
+    uint16_t word3CE00;
+    uint16_t fill;
+    char char3CE04;
+    char gap3CE05[63];
+    char char3CE44;
+    char gap3CE45[15];
+    char char3CE54;
+    char gap3CE55[15];
+    char char3CE64;
+    char gap3CE65[15];
+    char char3CE74;
+    char gap3CE75[15];
+    char char3CE84;
+    char gap3CE85[15];
+    char byte3CE94;
+    char char3CE95;
+    char gap3CE96[2];
+    char dupa;
+    char gap3cE99[108];
+    char char3CF05;
+    char gap3CF06[2];
+    char cipa;
+    char gap3CF09[12];
+    char byte3CF15;
+    char fillaaaa[2];
+    bool bool3CF18;
+    int elo;
+    int elo22;
 };
diff --git a/src/Minecraft.Client/renderer/UnknownRendererClasses.h b/src/Minecraft.Client/renderer/UnknownRendererClasses.h
new file mode 100644
index 00000000..32a7434c
--- /dev/null
+++ b/src/Minecraft.Client/renderer/UnknownRendererClasses.h
@@ -0,0 +1,7 @@
+#include <cstddef>
+class class_71007B7E78 {
+public:
+    class_71007B7E78(size_t, int);
+
+    char filler[0x28];
+};
\ No newline at end of file