diff --git a/bootloader/config/config.c b/bootloader/config/config.c
index af8e6aa..61f28d6 100644
--- a/bootloader/config/config.c
+++ b/bootloader/config/config.c
@@ -154,20 +154,20 @@ int create_config_entry()
 
 static void _save_config()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	if (!create_config_entry())
-		gfx_puts(&gfx_con, "\nConfiguration was saved!\n");
+		gfx_puts("\nConfiguration was saved!\n");
 	else
 		EPRINTF("\nConfiguration saving failed!");
-	gfx_puts(&gfx_con, "\nPress any key...");
+	gfx_puts("\nPress any key...");
 }
 
 static void _config_autoboot_list(void *ent)
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	u32 *temp_autoboot = NULL;
 
@@ -225,7 +225,7 @@ static void _config_autoboot_list(void *ent)
 
 			memset(&ments[i], 0, sizeof(ment_t));
 			menu_t menu = {ments, "Select an entry to auto boot", 0, 0};
-			temp_autoboot = (u32 *)tui_do_menu(&gfx_con, &menu);
+			temp_autoboot = (u32 *)tui_do_menu(&menu);
 			if (temp_autoboot != NULL)
 			{
 				h_cfg.autoboot = *(u32 *)temp_autoboot;
@@ -258,8 +258,8 @@ out2:;
 
 void config_autoboot()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	u32 *temp_autoboot = NULL;
 
@@ -341,7 +341,7 @@ void config_autoboot()
 
 			memset(&ments[i], 0, sizeof(ment_t));
 			menu_t menu = {ments, "Disable or select entry to auto boot", 0, 0};
-			temp_autoboot = (u32 *)tui_do_menu(&gfx_con, &menu);
+			temp_autoboot = (u32 *)tui_do_menu(&menu);
 			if (temp_autoboot != NULL)
 			{
 				h_cfg.autoboot = *(u32 *)temp_autoboot;
@@ -374,8 +374,8 @@ out2:;
 
 void config_bootdelay()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	u32 delay_entries = 6;
 
@@ -416,7 +416,7 @@ void config_bootdelay()
 	memset(&ments[i + 2], 0, sizeof(ment_t));
 	menu_t menu = {ments, "Time delay for entering bootloader menu", 0, 0};
 
-	u32 *temp_bootwait = (u32 *)tui_do_menu(&gfx_con, &menu);
+	u32 *temp_bootwait = (u32 *)tui_do_menu(&menu);
 	if (temp_bootwait != NULL)
 	{
 		h_cfg.bootwait = *(u32 *)temp_bootwait;
@@ -434,8 +434,8 @@ void config_bootdelay()
 
 void config_verification()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	ment_t *ments = (ment_t *)malloc(sizeof(ment_t) * 6);
 	u32 *vr_values = (u32 *)malloc(sizeof(u32) * 3);
@@ -469,7 +469,7 @@ void config_verification()
 	memset(&ments[5], 0, sizeof(ment_t));
 	menu_t menu = {ments, "Backup & Restore verification", 0, 0};
 
-	u32 *temp_verification = (u32 *)tui_do_menu(&gfx_con, &menu);
+	u32 *temp_verification = (u32 *)tui_do_menu(&menu);
 	if (temp_verification != NULL)
 	{
 		h_cfg.verification = *(u32 *)temp_verification;
@@ -487,8 +487,8 @@ void config_verification()
 
 void config_backlight()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	u32 bri_entries = 11;
 
@@ -528,7 +528,7 @@ void config_backlight()
 	memset(&ments[i + 1], 0, sizeof(ment_t));
 	menu_t menu = {ments, "Backlight brightness", 0, 0};
 
-	u32 *temp_backlight = (u32 *)tui_do_menu(&gfx_con, &menu);
+	u32 *temp_backlight = (u32 *)tui_do_menu(&menu);
 	if (temp_backlight != NULL)
 	{
 		h_cfg.backlight = (*(u32 *)temp_backlight) * 2;
@@ -546,8 +546,8 @@ void config_backlight()
 
 void config_auto_hos_poweroff()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	ment_t *ments = (ment_t *)malloc(sizeof(ment_t) * 6);
 	u32 *hp_values = (u32 *)malloc(sizeof(u32) * 3);
@@ -586,7 +586,7 @@ void config_auto_hos_poweroff()
 	memset(&ments[5], 0, sizeof(ment_t));
 	menu_t menu = {ments, "Power off if woke up from HOS", 0, 0};
 
-	u32 *temp_autohosoff = (u32 *)tui_do_menu(&gfx_con, &menu);
+	u32 *temp_autohosoff = (u32 *)tui_do_menu(&menu);
 	if (temp_autohosoff != NULL)
 	{
 		h_cfg.autohosoff = *(u32 *)temp_autohosoff;
@@ -603,8 +603,8 @@ void config_auto_hos_poweroff()
 
 void config_nogc()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	ment_t *ments = (ment_t *)malloc(sizeof(ment_t) * 5);
 	u32 *cb_values = (u32 *)malloc(sizeof(u32) * 2);
@@ -635,7 +635,7 @@ void config_nogc()
 	memset(&ments[4], 0, sizeof(ment_t));
 	menu_t menu = {ments, "No Gamecard", 0, 0};
 
-	u32 *temp_nogc = (u32 *)tui_do_menu(&gfx_con, &menu);
+	u32 *temp_nogc = (u32 *)tui_do_menu(&menu);
 	if (temp_nogc != NULL)
 	{
 		h_cfg.autonogc = *(u32 *)temp_nogc;
diff --git a/bootloader/frontend/fe_emmc_tools.c b/bootloader/frontend/fe_emmc_tools.c
index c272e2a..f2d78b2 100644
--- a/bootloader/frontend/fe_emmc_tools.c
+++ b/bootloader/frontend/fe_emmc_tools.c
@@ -66,7 +66,7 @@ static int _dump_emmc_verify(sdmmc_storage_t *storage, u32 lba_curr, char *outFi
 		u8 *bufSd = (u8 *)SDXC_BUF_ALIGNED;
 
 		u32 pct = (u64)((u64)(lba_curr - part->lba_start) * 100u) / (u64)(part->lba_end - part->lba_start);
-		tui_pbar(&gfx_con, 0, gfx_con.y, pct, 0xFF96FF00, 0xFF155500);
+		tui_pbar(0, gfx_con.y, pct, 0xFF96FF00, 0xFF155500);
 
 		u32 num = 0;
 		while (totalSectorsVer > 0)
@@ -114,7 +114,7 @@ static int _dump_emmc_verify(sdmmc_storage_t *storage, u32 lba_curr, char *outFi
 			pct = (u64)((u64)(lba_curr - part->lba_start) * 100u) / (u64)(part->lba_end - part->lba_start);
 			if (pct != prevPct)
 			{
-				tui_pbar(&gfx_con, 0, gfx_con.y, pct, 0xFF96FF00, 0xFF155500);
+				tui_pbar(0, gfx_con.y, pct, 0xFF96FF00, 0xFF155500);
 				prevPct = pct;
 			}
 
@@ -138,7 +138,7 @@ static int _dump_emmc_verify(sdmmc_storage_t *storage, u32 lba_curr, char *outFi
 		}
 		f_close(&fp);
 
-		tui_pbar(&gfx_con, 0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
+		tui_pbar(0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
 
 		return 0;
 	}
@@ -183,7 +183,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 	memcpy(partialIdxFilename, "partial.idx", 12);
 
 	gfx_con.fntsz = 8;
-	gfx_printf(&gfx_con, "\nSD Card free space: %d MiB, Total backup size %d MiB\n\n",
+	gfx_printf("\nSD Card free space: %d MiB, Total backup size %d MiB\n\n",
 		sd_fs.free_clst * sd_fs.csize >> SECTORS_TO_MIB_COEFF,
 		totalSectors >> SECTORS_TO_MIB_COEFF);
 
@@ -198,7 +198,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 	{
 		isSmallSdCard = true;
 
-		gfx_printf(&gfx_con, "%k\nSD card free space is smaller than total backup size.%k\n", 0xFFFFBA00, 0xFFCCCCCC);
+		gfx_printf("%k\nSD card free space is smaller than total backup size.%k\n", 0xFFFFBA00, 0xFFCCCCCC);
 
 		if (!maxSplitParts)
 		{
@@ -211,7 +211,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 	// Check if we are continuing a previous raw eMMC or USER partition backup in progress.
 	if (f_open(&partialIdxFp, partialIdxFilename, FA_READ) == FR_OK && totalSectors > (FAT32_FILESIZE_LIMIT / NX_EMMC_BLOCKSIZE))
 	{
-		gfx_printf(&gfx_con, "%kFound Partial Backup in progress. Continuing...%k\n\n", 0xFFAEFD14, 0xFFCCCCCC);
+		gfx_printf("%kFound Partial Backup in progress. Continuing...%k\n\n", 0xFFAEFD14, 0xFFCCCCCC);
 
 		partialDumpInProgress = true;
 		// Force partial dumping, even if the card is larger.
@@ -232,7 +232,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 		maxSplitParts += currPartIdx;
 	}
 	else if (isSmallSdCard)
-		gfx_printf(&gfx_con, "%kPartial Backup enabled (with %d MiB parts)...%k\n\n", 0xFFFFBA00, multipartSplitSize >> 20, 0xFFCCCCCC);
+		gfx_printf("%kPartial Backup enabled (with %d MiB parts)...%k\n\n", 0xFFFFBA00, multipartSplitSize >> 20, 0xFFCCCCCC);
 
 	// Check if filesystem is FAT32 or the free space is smaller and backup in parts.
 	if (((sd_fs.fs_type != FS_EXFAT) && totalSectors > (FAT32_FILESIZE_LIMIT / NX_EMMC_BLOCKSIZE)) | isSmallSdCard)
@@ -247,7 +247,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 	}
 
 	FIL fp;
-	gfx_con_getpos(&gfx_con, &gfx_con.savedx, &gfx_con.savedy);
+	gfx_con_getpos(&gfx_con.savedx, &gfx_con.savedy);
 	if (!f_open(&fp, outFilename, FA_READ))
 	{
 		f_close(&fp);
@@ -260,10 +260,10 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 		if (!(btn_wait() & BTN_POWER))
 			return 0;
 		gfx_con.fntsz = 8;
-		gfx_clear_partial_grey(&gfx_ctxt, 0x1B, gfx_con.savedy, 48);
+		gfx_clear_partial_grey(0x1B, gfx_con.savedy, 48);
 	}
-	gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-	gfx_printf(&gfx_con, "Filename: %s\n\n", outFilename);
+	gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+	gfx_printf("Filename: %s\n\n", outFilename);
 	res = f_open(&fp, outFilename, FA_CREATE_ALWAYS | FA_WRITE);
 	if (res)
 	{
@@ -338,7 +338,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 				// More parts to backup that do not currently fit the sd card free space or fatal error.
 				if (currPartIdx >= maxSplitParts)
 				{
-					gfx_puts(&gfx_con, "\n\n1. Press any key to unmount SD Card.\n\
+					gfx_puts("\n\n1. Press any key to unmount SD Card.\n\
 						2. Remove SD Card and move files to free space.\n\
 						   Don\'t move the partial.idx file!\n\
 						3. Re-insert SD Card.\n\
@@ -350,8 +350,8 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 			}
 
 			// Create next part.
-			gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-			gfx_printf(&gfx_con, "Filename: %s\n\n", outFilename);
+			gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+			gfx_printf("Filename: %s\n\n", outFilename);
 			lbaStartPart = lba_curr;
 			res = f_open(&fp, outFilename, FA_CREATE_ALWAYS | FA_WRITE);
 			if (res)
@@ -404,7 +404,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 		pct = (u64)((u64)(lba_curr - part->lba_start) * 100u) / (u64)(part->lba_end - part->lba_start);
 		if (pct != prevPct)
 		{
-			tui_pbar(&gfx_con, 0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
+			tui_pbar(0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
 			prevPct = pct;
 		}
 
@@ -433,7 +433,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 			return 0;
 		}
 	}
-	tui_pbar(&gfx_con, 0, gfx_con.y, 100, 0xFFCCCCCC, 0xFF555555);
+	tui_pbar(0, gfx_con.y, 100, 0xFFCCCCCC, 0xFF555555);
 
 	// Backup operation ended successfully.
 	f_close(&fp);
@@ -448,7 +448,7 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 			return 0;
 		}
 		else
-			tui_pbar(&gfx_con, 0, gfx_con.y, 100, 0xFF96FF00, 0xFF155500);
+			tui_pbar(0, gfx_con.y, 100, 0xFF96FF00, 0xFF155500);
 	}
 
 	gfx_con.fntsz = 16;
@@ -456,9 +456,9 @@ static int _dump_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part_t
 	if (isSmallSdCard)
 	{
 		f_unlink(partialIdxFilename);
-		gfx_printf(&gfx_con, "%k\n\nYou can now join the files\nand get the complete eMMC RAW GPP backup.", 0xFFCCCCCC);
+		gfx_printf("%k\n\nYou can now join the files\nand get the complete eMMC RAW GPP backup.", 0xFFCCCCCC);
 	}
-	gfx_puts(&gfx_con, "\n\n");
+	gfx_puts("\n\n");
 
 	return 1;
 }
@@ -476,14 +476,14 @@ static void _dump_emmc_selected(emmcPartType_t dumpType)
 {
 	int res = 0;
 	u32 timer = 0;
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	tui_sbar(&gfx_con, true);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	tui_sbar(true);
+	gfx_con_setpos(0, 0);
 
 	if (!sd_mount())
 		goto out;
 
-	gfx_puts(&gfx_con, "Checking for available free space...\n\n");
+	gfx_puts("Checking for available free space...\n\n");
 	// Get SD Card free space for Partial Backup.
 	f_getfree("", &sd_fs.free_clst, NULL);
 
@@ -516,7 +516,7 @@ static void _dump_emmc_selected(emmcPartType_t dumpType)
 			bootPart.name[4] = (u8)('0' + i);
 			bootPart.name[5] = 0;
 
-			gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i,
+			gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i,
 				bootPart.name, bootPart.lba_start, bootPart.lba_end, 0xFFCCCCCC);
 
 			sdmmc_storage_set_mmc_partition(&storage, i + 1);
@@ -541,7 +541,7 @@ static void _dump_emmc_selected(emmcPartType_t dumpType)
 				if ((dumpType & PART_SYSTEM) == 0 && strcmp(part->name, "USER"))
 					continue;
 
-				gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
+				gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
 					part->name, part->lba_start, part->lba_end, 0xFFCCCCCC);
 
 				emmcsn_path_impl(sdPath, "/partitions", part->name, &storage);
@@ -564,7 +564,7 @@ static void _dump_emmc_selected(emmcPartType_t dumpType)
 			rawPart.lba_end = RAW_AREA_NUM_SECTORS - 1;
 			strcpy(rawPart.name, "rawnand.bin");
 			{
-				gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
+				gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
 					rawPart.name, rawPart.lba_start, rawPart.lba_end, 0xFFCCCCCC);
 
 				emmcsn_path_impl(sdPath, "", rawPart.name, &storage);
@@ -573,14 +573,14 @@ static void _dump_emmc_selected(emmcPartType_t dumpType)
 		}
 	}
 
-	gfx_putc(&gfx_con, '\n');
+	gfx_putc('\n');
 	timer = get_tmr_s() - timer;
-	gfx_printf(&gfx_con, "Time taken: %dm %ds.\n", timer / 60, timer % 60);
+	gfx_printf("Time taken: %dm %ds.\n", timer / 60, timer % 60);
 	sdmmc_storage_end(&storage);
 	if (res && h_cfg.verification)
-		gfx_printf(&gfx_con, "\n%kFinished and verified!%k\nPress any key...\n", 0xFF96FF00, 0xFFCCCCCC);
+		gfx_printf("\n%kFinished and verified!%k\nPress any key...\n", 0xFF96FF00, 0xFFCCCCCC);
 	else if (res)
-		gfx_printf(&gfx_con, "\nFinished! Press any key...\n");
+		gfx_printf("\nFinished! Press any key...\n");
 
 out:
 	sd_unmount();
@@ -610,7 +610,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 	FIL fp;
 	FILINFO fno;
 
-	gfx_con_getpos(&gfx_con, &gfx_con.savedx, &gfx_con.savedy);
+	gfx_con_getpos(&gfx_con.savedx, &gfx_con.savedy);
 
     bool use_multipart = false;
 
@@ -620,7 +620,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 		if (f_stat(outFilename, &fno))
 		{
 			// If not, check if there are partial files and the total size matches.
-			gfx_printf(&gfx_con, "No single file, checking for part files...\n");
+			gfx_printf("No single file, checking for part files...\n");
 
 			outFilename[sdPathLen++] = '.';
 
@@ -629,8 +629,8 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 			{
 				_update_filename(outFilename, sdPathLen, 99, numSplitParts);
 
-				gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-				gfx_printf(&gfx_con, "\nFilename: %s\n", outFilename);
+				gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+				gfx_printf("\nFilename: %s\n", outFilename);
 
 				if (f_stat(outFilename, &fno))
 				{
@@ -643,7 +643,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 				numSplitParts++;
 			}
 
-			gfx_printf(&gfx_con, "\n%X sectors total.\n", (u32)((u64)totalCheckFileSize >> (u64)9));
+			gfx_printf("\n%X sectors total.\n", (u32)((u64)totalCheckFileSize >> (u64)9));
 
 			if ((u32)((u64)totalCheckFileSize >> (u64)9) != totalSectors)
 			{
@@ -661,8 +661,8 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 	}
 
 	res = f_open(&fp, outFilename, FA_READ);
-	gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-	gfx_printf(&gfx_con, "\nFilename: %s\n", outFilename);
+	gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+	gfx_printf("\nFilename: %s\n", outFilename);
 	if (res)
 	{
 		if (res != FR_NO_FILE)
@@ -684,7 +684,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 	else
 	{
 		fileSize = (u64)f_size(&fp);
-		gfx_printf(&gfx_con, "\nTotal restore size: %d MiB.\n\n",
+		gfx_printf("\nTotal restore size: %d MiB.\n\n",
 			(u32)((use_multipart ? (u64)totalCheckFileSize : fileSize) >> (u64)9) >> SECTORS_TO_MIB_COEFF);
 	}
 
@@ -698,7 +698,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 	u32 num = 0;
 	u32 pct = 0;
 
-	gfx_con_getpos(&gfx_con, &gfx_con.savedx, &gfx_con.savedy);
+	gfx_con_getpos(&gfx_con.savedx, &gfx_con.savedy);
 
 	while (totalSectors > 0)
 	{
@@ -724,8 +724,8 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 			_update_filename(outFilename, sdPathLen, numSplitParts, currPartIdx);
 
 			// Read from next part.
-			gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-			gfx_printf(&gfx_con, "Filename: %s\n\n", outFilename);
+			gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+			gfx_printf("Filename: %s\n\n", outFilename);
 
 			lbaStartPart = lba_curr;
 
@@ -775,7 +775,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 		pct = (u64)((u64)(lba_curr - part->lba_start) * 100u) / (u64)(part->lba_end - part->lba_start);
 		if (pct != prevPct)
 		{
-			tui_pbar(&gfx_con, 0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
+			tui_pbar(0, gfx_con.y, pct, 0xFFCCCCCC, 0xFF555555);
 			prevPct = pct;
 		}
 
@@ -783,7 +783,7 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 		totalSectors -= num;
 		bytesWritten += num * NX_EMMC_BLOCKSIZE;
 	}
-	tui_pbar(&gfx_con, 0, gfx_con.y, 100, 0xFFCCCCCC, 0xFF555555);
+	tui_pbar(0, gfx_con.y, 100, 0xFFCCCCCC, 0xFF555555);
 
 	// Restore operation ended successfully.
 	f_close(&fp);
@@ -798,11 +798,11 @@ static int _restore_emmc_part(char *sd_path, sdmmc_storage_t *storage, emmc_part
 			return 0;
 		}
 		else
-			tui_pbar(&gfx_con, 0, gfx_con.y, 100, 0xFF96FF00, 0xFF155500);
+			tui_pbar(0, gfx_con.y, 100, 0xFF96FF00, 0xFF155500);
 	}
 
 	gfx_con.fntsz = 16;
-	gfx_puts(&gfx_con, "\n\n");
+	gfx_puts("\n\n");
 
 	return 1;
 }
@@ -811,33 +811,33 @@ static void _restore_emmc_selected(emmcPartType_t restoreType)
 {
 	int res = 0;
 	u32 timer = 0;
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	tui_sbar(&gfx_con, true);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	tui_sbar(true);
+	gfx_con_setpos(0, 0);
 
-	gfx_printf(&gfx_con, "%kThis may render your device inoperative!\n\n", 0xFFFFDD00);
-	gfx_printf(&gfx_con, "Are you really sure?\n\n%k", 0xFFCCCCCC);
+	gfx_printf("%kThis may render your device inoperative!\n\n", 0xFFFFDD00);
+	gfx_printf("Are you really sure?\n\n%k", 0xFFCCCCCC);
 	if ((restoreType & PART_BOOT) || (restoreType & PART_GP_ALL))
 	{
-		gfx_puts(&gfx_con, "The mode you selected will only restore\nthe ");
+		gfx_puts("The mode you selected will only restore\nthe ");
 		if (restoreType & PART_BOOT)
-			gfx_puts(&gfx_con, "boot ");
-		gfx_puts(&gfx_con, "partitions that it can find.\n");
-		gfx_puts(&gfx_con, "If it is not found, it will be skipped\nand continue with the next.\n\n");
+			gfx_puts("boot ");
+		gfx_puts("partitions that it can find.\n");
+		gfx_puts("If it is not found, it will be skipped\nand continue with the next.\n\n");
 	}
-	gfx_con_getpos(&gfx_con, &gfx_con.savedx, &gfx_con.savedy);
+	gfx_con_getpos(&gfx_con.savedx, &gfx_con.savedy);
 
 	u8 failsafe_wait = 10;
 	while (failsafe_wait > 0)
 	{
-		gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-		gfx_printf(&gfx_con, "%kWait... (%ds)    %k", 0xFF888888, failsafe_wait, 0xFFCCCCCC);
+		gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+		gfx_printf("%kWait... (%ds)    %k", 0xFF888888, failsafe_wait, 0xFFCCCCCC);
 		msleep(1000);
 		failsafe_wait--;
 	}
-	gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
+	gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
 
-	gfx_puts(&gfx_con, "Press POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
+	gfx_puts("Press POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
 
 	u32 btn = btn_wait();
 	if (!(btn & BTN_POWER))
@@ -872,7 +872,7 @@ static void _restore_emmc_selected(emmcPartType_t restoreType)
 			bootPart.name[4] = (u8)('0' + i);
 			bootPart.name[5] = 0;
 
-			gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i,
+			gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i,
 				bootPart.name, bootPart.lba_start, bootPart.lba_end, 0xFFCCCCCC);
 
 			sdmmc_storage_set_mmc_partition(&storage, i + 1);
@@ -890,7 +890,7 @@ static void _restore_emmc_selected(emmcPartType_t restoreType)
 		nx_emmc_gpt_parse(&gpt, &storage);
 		LIST_FOREACH_ENTRY(emmc_part_t, part, &gpt, link)
 		{
-			gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
+			gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
 				part->name, part->lba_start, part->lba_end, 0xFFCCCCCC);
 
 			emmcsn_path_impl(sdPath, "/restore/partitions/", part->name, &storage);
@@ -910,7 +910,7 @@ static void _restore_emmc_selected(emmcPartType_t restoreType)
 		rawPart.lba_end = RAW_AREA_NUM_SECTORS - 1;
 		strcpy(rawPart.name, "rawnand.bin");
 		{
-			gfx_printf(&gfx_con, "%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
+			gfx_printf("%k%02d: %s (%07X-%07X)%k\n", 0xFF00DDFF, i++,
 				rawPart.name, rawPart.lba_start, rawPart.lba_end, 0xFFCCCCCC);
 
 			emmcsn_path_impl(sdPath, "/restore", rawPart.name, &storage);
@@ -918,14 +918,14 @@ static void _restore_emmc_selected(emmcPartType_t restoreType)
 		}
 	}
 
-	gfx_putc(&gfx_con, '\n');
+	gfx_putc('\n');
 	timer = get_tmr_s() - timer;
-	gfx_printf(&gfx_con, "Time taken: %dm %ds.\n", timer / 60, timer % 60);
+	gfx_printf("Time taken: %dm %ds.\n", timer / 60, timer % 60);
 	sdmmc_storage_end(&storage);
 	if (res && h_cfg.verification)
-		gfx_printf(&gfx_con, "\n%kFinished and verified!%k\nPress any key...\n", 0xFF96FF00, 0xFFCCCCCC);
+		gfx_printf("\n%kFinished and verified!%k\nPress any key...\n", 0xFF96FF00, 0xFFCCCCCC);
 	else if (res)
-		gfx_printf(&gfx_con, "\nFinished! Press any key...\n");
+		gfx_printf("\nFinished! Press any key...\n");
 
 out:
 	sd_unmount();
diff --git a/bootloader/frontend/fe_info.c b/bootloader/frontend/fe_info.c
index d2e7b20..e58fe6e 100644
--- a/bootloader/frontend/fe_info.c
+++ b/bootloader/frontend/fe_info.c
@@ -48,8 +48,8 @@ extern void emmcsn_path_impl(char *path, char *sub_dir, char *filename, sdmmc_st
 
 void print_fuseinfo()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	u32 burntFuses = 0;
 	for (u32 i = 0; i < 32; i++)
@@ -58,26 +58,26 @@ void print_fuseinfo()
 			burntFuses++;
 	}
 
-	gfx_printf(&gfx_con, "\nSKU:         %X - ", FUSE(FUSE_SKU_INFO));
+	gfx_printf("\nSKU:         %X - ", FUSE(FUSE_SKU_INFO));
 	switch (fuse_read_odm(4) & 3)
 	{
 	case 0:
-		gfx_printf(&gfx_con, "Retail\n");
+		gfx_printf("Retail\n");
 		break;
 	case 3:
-		gfx_printf(&gfx_con, "Dev\n");
+		gfx_printf("Dev\n");
 		break;
 	}
-	gfx_printf(&gfx_con, "Sdram ID:    %d\n", (fuse_read_odm(4) >> 3) & 0x1F);
-	gfx_printf(&gfx_con, "Burnt fuses: %d / 64\n", burntFuses);
-	gfx_printf(&gfx_con, "Secure key:  %08X%08X%08X%08X\n\n\n",
+	gfx_printf("Sdram ID:    %d\n", (fuse_read_odm(4) >> 3) & 0x1F);
+	gfx_printf("Burnt fuses: %d / 64\n", burntFuses);
+	gfx_printf("Secure key:  %08X%08X%08X%08X\n\n\n",
 		byte_swap_32(FUSE(FUSE_PRIVATE_KEY0)), byte_swap_32(FUSE(FUSE_PRIVATE_KEY1)),
 		byte_swap_32(FUSE(FUSE_PRIVATE_KEY2)), byte_swap_32(FUSE(FUSE_PRIVATE_KEY3)));
 
-	gfx_printf(&gfx_con, "%k(Unlocked) fuse cache:\n\n%k", 0xFF00DDFF, 0xFFCCCCCC);
-	gfx_hexdump(&gfx_con, 0x7000F900, (u8 *)0x7000F900, 0x2FC);
+	gfx_printf("%k(Unlocked) fuse cache:\n\n%k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_hexdump(0x7000F900, (u8 *)0x7000F900, 0x2FC);
 
-	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
+	gfx_puts("\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
@@ -87,7 +87,7 @@ void print_fuseinfo()
 			char path[64];
 			emmcsn_path_impl(path, "/dumps", "fuses.bin", NULL);
 			if (!sd_save_to_file((u8 *)0x7000F900, 0x2FC, path))
-				gfx_puts(&gfx_con, "\nDone!\n");
+				gfx_puts("\nDone!\n");
 			sd_unmount();
 		}
 
@@ -97,17 +97,17 @@ void print_fuseinfo()
 
 void print_kfuseinfo()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
-	gfx_printf(&gfx_con, "%kKFuse contents:\n\n%k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_printf("%kKFuse contents:\n\n%k", 0xFF00DDFF, 0xFFCCCCCC);
 	u32 buf[KFUSE_NUM_WORDS];
 	if (!kfuse_read(buf))
 		EPRINTF("CRC fail.");
 	else
-		gfx_hexdump(&gfx_con, 0, (u8 *)buf, KFUSE_NUM_WORDS * 4);
+		gfx_hexdump(0, (u8 *)buf, KFUSE_NUM_WORDS * 4);
 
-	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
+	gfx_puts("\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
@@ -117,7 +117,7 @@ void print_kfuseinfo()
 			char path[64];
 			emmcsn_path_impl(path, "/dumps", "kfuses.bin", NULL);
 			if (!sd_save_to_file((u8 *)buf, KFUSE_NUM_WORDS * 4, path))
-				gfx_puts(&gfx_con, "\nDone!\n");
+				gfx_puts("\nDone!\n");
 			sd_unmount();
 		}
 
@@ -127,8 +127,8 @@ void print_kfuseinfo()
 
 void print_mmc_info()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	static const u32 SECTORS_TO_MIB_COEFF = 11;
 
@@ -145,12 +145,12 @@ void print_mmc_info()
 		u16 card_type;
 		u32 speed = 0;
 
-		gfx_printf(&gfx_con, "%kCID:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
+		gfx_printf("%kCID:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
 		switch (storage.csd.mmca_vsn)
 		{
 		case 0: /* MMC v1.0 - v1.2 */
 		case 1: /* MMC v1.4 */
-			gfx_printf(&gfx_con,
+			gfx_printf(
 				" Vendor ID:  %03X\n"
 				" Model:      %c%c%c%c%c%c%c\n"
 				" HW rev:     %X\n"
@@ -166,7 +166,7 @@ void print_mmc_info()
 		case 2: /* MMC v2.0 - v2.2 */
 		case 3: /* MMC v3.1 - v3.3 */
 		case 4: /* MMC v4 */
-			gfx_printf(&gfx_con,
+			gfx_printf(
 				" Vendor ID:  %X\n"
 				" Card/BGA:   %X\n"
 				" OEM ID:     %02X\n"
@@ -188,7 +188,7 @@ void print_mmc_info()
 			EPRINTF("Unknown CSD structure.");
 		else
 		{
-			gfx_printf(&gfx_con, "%kExtended CSD V1.%d:%k\n",
+			gfx_printf("%kExtended CSD V1.%d:%k\n",
 				0xFF00DDFF, storage.ext_csd.ext_struct, 0xFFCCCCCC);
 			card_type = storage.ext_csd.card_type;
 			u8 card_type_support[96];
@@ -226,7 +226,7 @@ void print_mmc_info()
 			}
 			card_type_support[pos_type] = 0;
 
-			gfx_printf(&gfx_con,
+			gfx_printf(
 				" Spec Version:  %02X\n"
 				" Extended Rev:  1.%d\n"
 				" Dev Version:   %d\n"
@@ -239,26 +239,26 @@ void print_mmc_info()
 				storage.csd.capacity == (4096 * 512) ? "High" : "Low", speed & 0xFFFF, (speed >> 16) & 0xFFFF,
 				storage.csd.busspeed);
 			gfx_con.fntsz = 8;
-			gfx_printf(&gfx_con, "%s", card_type_support);
+			gfx_printf("%s", card_type_support);
 			gfx_con.fntsz = 16;
-			gfx_printf(&gfx_con, "\n\n", card_type_support);
+			gfx_printf("\n\n", card_type_support);
 
 			u32 boot_size = storage.ext_csd.boot_mult << 17;
 			u32 rpmb_size = storage.ext_csd.rpmb_mult << 17;
-			gfx_printf(&gfx_con, "%keMMC Partitions:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
-			gfx_printf(&gfx_con, " 1: %kBOOT0      %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
+			gfx_printf("%keMMC Partitions:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
+			gfx_printf(" 1: %kBOOT0      %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
 				boot_size / 1024, boot_size / 1024 / 512);
 			gfx_put_small_sep(&gfx_con);
-			gfx_printf(&gfx_con, " 2: %kBOOT1      %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
+			gfx_printf(" 2: %kBOOT1      %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
 				boot_size / 1024, boot_size / 1024 / 512);
 			gfx_put_small_sep(&gfx_con);
-			gfx_printf(&gfx_con, " 3: %kRPMB       %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
+			gfx_printf(" 3: %kRPMB       %k\n    Size: %5d KiB (LBA Sectors: 0x%07X)\n", 0xFF96FF00, 0xFFCCCCCC,
 				rpmb_size / 1024, rpmb_size / 1024 / 512);
 			gfx_put_small_sep(&gfx_con);
-			gfx_printf(&gfx_con, " 0: %kGPP (USER) %k\n    Size: %5d MiB (LBA Sectors: 0x%07X)\n\n", 0xFF96FF00, 0xFFCCCCCC,
+			gfx_printf(" 0: %kGPP (USER) %k\n    Size: %5d MiB (LBA Sectors: 0x%07X)\n\n", 0xFF96FF00, 0xFFCCCCCC,
 				storage.sec_cnt >> SECTORS_TO_MIB_COEFF, storage.sec_cnt);
 			gfx_put_small_sep(&gfx_con);
-			gfx_printf(&gfx_con, "%kGPP (eMMC USER) partition table:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
+			gfx_printf("%kGPP (eMMC USER) partition table:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
 
 			sdmmc_storage_set_mmc_partition(&storage, 0);
 			LIST_INIT(gpt);
@@ -266,7 +266,7 @@ void print_mmc_info()
 			int gpp_idx = 0;
 			LIST_FOREACH_ENTRY(emmc_part_t, part, &gpt, link)
 			{
-				gfx_printf(&gfx_con, " %02d: %k%s%k\n     Size: % 5d MiB (LBA Sectors 0x%07X)\n     LBA Range: %08X-%08X\n",
+				gfx_printf(" %02d: %k%s%k\n     Size: % 5d MiB (LBA Sectors 0x%07X)\n     LBA Range: %08X-%08X\n",
 					gpp_idx++, 0xFFAEFD14, part->name, 0xFFCCCCCC, (part->lba_end - part->lba_start + 1) >> SECTORS_TO_MIB_COEFF,
 					part->lba_end - part->lba_start + 1, part->lba_start, part->lba_end);
 				gfx_put_small_sep(&gfx_con);
@@ -285,15 +285,15 @@ void print_sdcard_info()
 {
 	static const u32 SECTORS_TO_MIB_COEFF = 11;
 
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	if (sd_mount())
 	{
 		u32 capacity;
 
-		gfx_printf(&gfx_con, "%kCard IDentification:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
-		gfx_printf(&gfx_con,
+		gfx_printf("%kCard IDentification:%k\n", 0xFF00DDFF, 0xFFCCCCCC);
+		gfx_printf(
 			" Vendor ID:  %02x\n"
 			" OEM ID:     %c%c\n"
 			" Model:      %c%c%c%c%c\n"
@@ -307,9 +307,9 @@ void print_sdcard_info()
 			sd_storage.cid.hwrev, sd_storage.cid.fwrev, sd_storage.cid.serial,
 			sd_storage.cid.month, sd_storage.cid.year);
 
-		gfx_printf(&gfx_con, "%kCard-Specific Data V%d.0:%k\n", 0xFF00DDFF, sd_storage.csd.structure + 1, 0xFFCCCCCC);
+		gfx_printf("%kCard-Specific Data V%d.0:%k\n", 0xFF00DDFF, sd_storage.csd.structure + 1, 0xFFCCCCCC);
 		capacity = sd_storage.csd.capacity >> (20 - sd_storage.csd.read_blkbits);
-		gfx_printf(&gfx_con,
+		gfx_printf(
 			" Cmd Classes:    %02X\n"
 			" Capacity:       %d MiB\n"
 			" Bus Width:      %d\n"
@@ -324,9 +324,9 @@ void print_sdcard_info()
 			sd_storage.ssr.speed_class, sd_storage.ssr.uhs_grade, sd_storage.ssr.video_class,
 			sd_storage.ssr.app_class, sd_storage.csd.write_protect);
 
-		gfx_puts(&gfx_con, "Acquiring FAT volume info...\n\n");
+		gfx_puts("Acquiring FAT volume info...\n\n");
 		f_getfree("", &sd_fs.free_clst, NULL);
-		gfx_printf(&gfx_con, "%kFound %s volume:%k\n Free:    %d MiB\n Cluster: %d KiB\n",
+		gfx_printf("%kFound %s volume:%k\n Free:    %d MiB\n Cluster: %d KiB\n",
 				0xFF00DDFF, sd_fs.fs_type == FS_EXFAT ? "exFAT" : "FAT32", 0xFFCCCCCC,
 				sd_fs.free_clst * sd_fs.csize >> SECTORS_TO_MIB_COEFF, (sd_fs.csize > 1) ? (sd_fs.csize >> 1) : 512);
 		sd_unmount();
@@ -337,8 +337,8 @@ void print_sdcard_info()
 
 void print_tsec_key()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	u32 retries = 0;
 
@@ -401,25 +401,25 @@ void print_tsec_key()
 		}
 	}
 
-	gfx_printf(&gfx_con, "%kTSEC key:  %k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_printf("%kTSEC key:  %k", 0xFF00DDFF, 0xFFCCCCCC);
 
 	if (res >= 0)
 	{
 		for (u32 j = 0; j < 0x10; j++)
-			gfx_printf(&gfx_con, "%02X", keys[j]);
+			gfx_printf("%02X", keys[j]);
 		
 
 		if (pkg1_id->kb == KB_FIRMWARE_VERSION_620)
 		{
-			gfx_printf(&gfx_con, "\n%kTSEC root: %k", 0xFF00DDFF, 0xFFCCCCCC);
+			gfx_printf("\n%kTSEC root: %k", 0xFF00DDFF, 0xFFCCCCCC);
 			for (u32 j = 0; j < 0x10; j++)
-				gfx_printf(&gfx_con, "%02X", keys[0x10 + j]);
+				gfx_printf("%02X", keys[0x10 + j]);
 		}
 	}
 	else
 		EPRINTFARGS("ERROR %X\n", res);
 
-	gfx_puts(&gfx_con, "\n\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
+	gfx_puts("\n\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
@@ -429,7 +429,7 @@ void print_tsec_key()
 			char path[64];
 			emmcsn_path_impl(path, "/dumps", "tsec_keys.bin", NULL);
 			if (!sd_save_to_file(keys, 0x10 * 2, path))
-				gfx_puts(&gfx_con, "\nDone!\n");
+				gfx_puts("\nDone!\n");
 			sd_unmount();
 		}
 	}
@@ -447,124 +447,124 @@ void print_fuel_gauge_info()
 {
 	int value = 0;
 
-	gfx_printf(&gfx_con, "%kFuel Gauge IC Info:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_printf("%kFuel Gauge IC Info:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
 
 	max17050_get_property(MAX17050_RepSOC, &value);
-	gfx_printf(&gfx_con, "Capacity now:           %3d%\n", value >> 8);
+	gfx_printf("Capacity now:           %3d%\n", value >> 8);
 
 	max17050_get_property(MAX17050_RepCap, &value);
-	gfx_printf(&gfx_con, "Capacity now:           %4d mAh\n", value);
+	gfx_printf("Capacity now:           %4d mAh\n", value);
 
 	max17050_get_property(MAX17050_FullCAP, &value);
-	gfx_printf(&gfx_con, "Capacity full:          %4d mAh\n", value);
+	gfx_printf("Capacity full:          %4d mAh\n", value);
 
 	max17050_get_property(MAX17050_DesignCap, &value);
-	gfx_printf(&gfx_con, "Capacity (design):      %4d mAh\n", value);
+	gfx_printf("Capacity (design):      %4d mAh\n", value);
 
 	max17050_get_property(MAX17050_Current, &value);
 	if (value >= 0)
-		gfx_printf(&gfx_con, "Current now:            %d mA\n", value / 1000);
+		gfx_printf("Current now:            %d mA\n", value / 1000);
 	else
-		gfx_printf(&gfx_con, "Current now:            -%d mA\n", ~value / 1000);
+		gfx_printf("Current now:            -%d mA\n", ~value / 1000);
 
 	max17050_get_property(MAX17050_AvgCurrent, &value);
 	if (value >= 0)
-		gfx_printf(&gfx_con, "Current average:        %d mA\n", value / 1000);
+		gfx_printf("Current average:        %d mA\n", value / 1000);
 	else
-		gfx_printf(&gfx_con, "Current average:        -%d mA\n", ~value / 1000);
+		gfx_printf("Current average:        -%d mA\n", ~value / 1000);
 
 	max17050_get_property(MAX17050_VCELL, &value);
-	gfx_printf(&gfx_con, "Voltage now:            %4d mV\n", value);
+	gfx_printf("Voltage now:            %4d mV\n", value);
 
 	max17050_get_property(MAX17050_OCVInternal, &value);
-	gfx_printf(&gfx_con, "Voltage open-circuit:   %4d mV\n", value);
+	gfx_printf("Voltage open-circuit:   %4d mV\n", value);
 
 	max17050_get_property(MAX17050_MinVolt, &value);
-	gfx_printf(&gfx_con, "Min voltage reached:    %4d mV\n", value);
+	gfx_printf("Min voltage reached:    %4d mV\n", value);
 
 	max17050_get_property(MAX17050_MaxVolt, &value);
-	gfx_printf(&gfx_con, "Max voltage reached:    %4d mV\n", value);
+	gfx_printf("Max voltage reached:    %4d mV\n", value);
 
 	max17050_get_property(MAX17050_V_empty, &value);
-	gfx_printf(&gfx_con, "Empty voltage (design): %4d mV\n", value);
+	gfx_printf("Empty voltage (design): %4d mV\n", value);
 
 	max17050_get_property(MAX17050_TEMP, &value);
 	if (value >= 0)
-		gfx_printf(&gfx_con, "Battery temperature:    %d.%d oC\n", value / 10, value % 10);
+		gfx_printf("Battery temperature:    %d.%d oC\n", value / 10, value % 10);
 	else
-		gfx_printf(&gfx_con, "Battery temperature:    -%d.%d oC\n", ~value / 10, (~value) % 10);
+		gfx_printf("Battery temperature:    -%d.%d oC\n", ~value / 10, (~value) % 10);
 }
 
 void print_battery_charger_info()
 {
 	int value = 0;
 
-	gfx_printf(&gfx_con, "%k\n\nBattery Charger IC Info:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_printf("%k\n\nBattery Charger IC Info:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
 
 	bq24193_get_property(BQ24193_InputVoltageLimit, &value);
-	gfx_printf(&gfx_con, "Input voltage limit:       %4d mV\n", value);
+	gfx_printf("Input voltage limit:       %4d mV\n", value);
 
 	bq24193_get_property(BQ24193_InputCurrentLimit, &value);
-	gfx_printf(&gfx_con, "Input current limit:       %4d mA\n", value);
+	gfx_printf("Input current limit:       %4d mA\n", value);
 
 	bq24193_get_property(BQ24193_SystemMinimumVoltage, &value);
-	gfx_printf(&gfx_con, "Min voltage limit:         %4d mV\n", value);
+	gfx_printf("Min voltage limit:         %4d mV\n", value);
 
 	bq24193_get_property(BQ24193_FastChargeCurrentLimit, &value);
-	gfx_printf(&gfx_con, "Fast charge current limit: %4d mA\n", value);
+	gfx_printf("Fast charge current limit: %4d mA\n", value);
 
 	bq24193_get_property(BQ24193_ChargeVoltageLimit, &value);
-	gfx_printf(&gfx_con, "Charge voltage limit:      %4d mV\n", value);
+	gfx_printf("Charge voltage limit:      %4d mV\n", value);
 
 	bq24193_get_property(BQ24193_ChargeStatus, &value);
-	gfx_printf(&gfx_con, "Charge status:             ");
+	gfx_printf("Charge status:             ");
 	switch (value)
 	{
 	case 0:
-		gfx_printf(&gfx_con, "Not charging\n");
+		gfx_printf("Not charging\n");
 		break;
 	case 1:
-		gfx_printf(&gfx_con, "Pre-charging\n");
+		gfx_printf("Pre-charging\n");
 		break;
 	case 2:
-		gfx_printf(&gfx_con, "Fast charging\n");
+		gfx_printf("Fast charging\n");
 		break;
 	case 3:
-		gfx_printf(&gfx_con, "Charge terminated\n");
+		gfx_printf("Charge terminated\n");
 		break;
 	default:
-		gfx_printf(&gfx_con, "Unknown (%d)\n", value);
+		gfx_printf("Unknown (%d)\n", value);
 		break;
 	}
 	bq24193_get_property(BQ24193_TempStatus, &value);
-	gfx_printf(&gfx_con, "Temperature status:        ");
+	gfx_printf("Temperature status:        ");
 	switch (value)
 	{
 	case 0:
-		gfx_printf(&gfx_con, "Normal\n");
+		gfx_printf("Normal\n");
 		break;
 	case 2:
-		gfx_printf(&gfx_con, "Warm\n");
+		gfx_printf("Warm\n");
 		break;
 	case 3:
-		gfx_printf(&gfx_con, "Cool\n");
+		gfx_printf("Cool\n");
 		break;
 	case 5:
-		gfx_printf(&gfx_con, "Cold\n");
+		gfx_printf("Cold\n");
 		break;
 	case 6:
-		gfx_printf(&gfx_con, "Hot\n");
+		gfx_printf("Hot\n");
 		break;
 	default:
-		gfx_printf(&gfx_con, "Unknown (%d)\n", value);
+		gfx_printf("Unknown (%d)\n", value);
 		break;
 	}
 }
 
 void print_battery_info()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	print_fuel_gauge_info();
 
@@ -572,7 +572,7 @@ void print_battery_info()
 
 	u8 *buf = (u8 *)malloc(0x100 * 2);
 
-	gfx_printf(&gfx_con, "%k\n\nBattery Fuel Gauge Registers:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
+	gfx_printf("%k\n\nBattery Fuel Gauge Registers:\n%k", 0xFF00DDFF, 0xFFCCCCCC);
 
 	for (int i = 0; i < 0x200; i += 2)
 	{
@@ -580,9 +580,9 @@ void print_battery_info()
 		usleep(2500);
 	}
 
-	gfx_hexdump(&gfx_con, 0, (u8 *)buf, 0x200);
+	gfx_hexdump(0, (u8 *)buf, 0x200);
 
-	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
+	gfx_puts("\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 
 	u32 btn = btn_wait();
 
@@ -595,7 +595,7 @@ void print_battery_info()
 			if (sd_save_to_file((u8 *)buf, 0x200, path))
 				EPRINTF("\nError creating fuel.bin file.");
 			else
-				gfx_puts(&gfx_con, "\nDone!\n");
+				gfx_puts("\nDone!\n");
 			sd_unmount();
 		}
 
@@ -606,24 +606,24 @@ void print_battery_info()
 
 void _ipatch_process(u32 offset, u32 value)
 {
-	gfx_printf(&gfx_con, "%8x %8x", BOOTROM_BASE + offset, value);
+	gfx_printf("%8x %8x", BOOTROM_BASE + offset, value);
 	u8 lo = value & 0xff;
 	switch (value >> 8)
 	{
 	case 0x20:
-		gfx_printf(&gfx_con, "    MOVS R0, #0x%02X", lo);
+		gfx_printf("    MOVS R0, #0x%02X", lo);
 		break;
 	case 0xDF:
-		gfx_printf(&gfx_con, "    SVC #0x%02X", lo);
+		gfx_printf("    SVC #0x%02X", lo);
 		break;
 	}
-	gfx_puts(&gfx_con, "\n");
+	gfx_puts("\n");
 }
 
 void bootrom_ipatches_info()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	static const u32 BOOTROM_SIZE = 0x18000;
 	
@@ -631,7 +631,7 @@ void bootrom_ipatches_info()
 	if (res != 0)
 		EPRINTFARGS("Failed to read ipatches. Error: %d", res);
 
-	gfx_puts(&gfx_con, "\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
+	gfx_puts("\nPress POWER to dump them to SD Card.\nPress VOL to go to the menu.\n");
 	
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
@@ -646,7 +646,7 @@ void bootrom_ipatches_info()
 			{
 				emmcsn_path_impl(path, "/dumps", "evp_thunks.bin", NULL);
 				if (!sd_save_to_file((u8 *)iram_evp_thunks, iram_evp_thunks_len, path))
-					gfx_puts(&gfx_con, "\nevp_thunks.bin saved!\n");
+					gfx_puts("\nevp_thunks.bin saved!\n");
 			}
 			else
 				EPRINTFARGS("Failed to read evp_thunks. Error: %d", res);
@@ -655,11 +655,11 @@ void bootrom_ipatches_info()
 			read_raw_fuses(words);
 			emmcsn_path_impl(path, "/dumps", "raw_fuses.bin", NULL);
 			if (!sd_save_to_file((u8 *)words, sizeof(words), path))
-				gfx_puts(&gfx_con, "\nipatches.bin saved!\n");
+				gfx_puts("\nipatches.bin saved!\n");
 			
 			emmcsn_path_impl(path, "/dumps", "bootrom_patched.bin", NULL);
 			if (!sd_save_to_file((u8 *)BOOTROM_BASE, BOOTROM_SIZE, path))
-				gfx_puts(&gfx_con, "\nbootrom_patched.bin saved!\n");
+				gfx_puts("\nbootrom_patched.bin saved!\n");
 			
 			u32 ipatch_backup[14];
 			memcpy(ipatch_backup, (void *)IPATCH_BASE, sizeof(ipatch_backup));
@@ -667,7 +667,7 @@ void bootrom_ipatches_info()
 			
 			emmcsn_path_impl(path, "/dumps", "bootrom_unpatched.bin", NULL);
 			if (!sd_save_to_file((u8 *)BOOTROM_BASE, BOOTROM_SIZE, path))
-				gfx_puts(&gfx_con, "\nbootrom_unpatched.bin saved!\n");
+				gfx_puts("\nbootrom_unpatched.bin saved!\n");
 			
 			memcpy((void*)IPATCH_BASE, ipatch_backup, sizeof(ipatch_backup));
 			
diff --git a/bootloader/frontend/fe_tools.c b/bootloader/frontend/fe_tools.c
index 46e2df4..00ddf93 100644
--- a/bootloader/frontend/fe_tools.c
+++ b/bootloader/frontend/fe_tools.c
@@ -58,8 +58,8 @@ void dump_packages12()
 
 	tsec_ctxt_t tsec_ctxt;
 
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	sdmmc_storage_t storage;
 	sdmmc_t sdmmc;
@@ -95,12 +95,12 @@ void dump_packages12()
 			b_cfg.autoboot = 0;
 			b_cfg.autoboot_list = 0;
 
-			gfx_printf(&gfx_con, "sept will run to get the keys.\nThen rerun this option.");
+			gfx_printf("sept will run to get the keys.\nThen rerun this option.");
 			btn_wait();
 
 			if (!reboot_to_sept((u8 *)tsec_ctxt.fw))
 			{
-				gfx_printf(&gfx_con, "Failed to run sept\n");
+				gfx_printf("Failed to run sept\n");
 				goto out_free;
 			}
 		}
@@ -126,37 +126,37 @@ void dump_packages12()
 		pkg1_unpack(warmboot, secmon, loader, pkg1_id, pkg1);
 	
 		// Display info.
-		gfx_printf(&gfx_con, "%kNX Bootloader size:  %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->ldr_size);
+		gfx_printf("%kNX Bootloader size:  %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->ldr_size);
 	
-		gfx_printf(&gfx_con, "%kSecure monitor addr: %k0x%05X\n", 0xFFC7EA46, 0xFFCCCCCC, pkg1_id->secmon_base);
-		gfx_printf(&gfx_con, "%kSecure monitor size: %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->sm_size);
+		gfx_printf("%kSecure monitor addr: %k0x%05X\n", 0xFFC7EA46, 0xFFCCCCCC, pkg1_id->secmon_base);
+		gfx_printf("%kSecure monitor size: %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->sm_size);
 	
-		gfx_printf(&gfx_con, "%kWarmboot addr:       %k0x%05X\n", 0xFFC7EA46, 0xFFCCCCCC, pkg1_id->warmboot_base);
-		gfx_printf(&gfx_con, "%kWarmboot size:       %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->wb_size);
+		gfx_printf("%kWarmboot addr:       %k0x%05X\n", 0xFFC7EA46, 0xFFCCCCCC, pkg1_id->warmboot_base);
+		gfx_printf("%kWarmboot size:       %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, hdr->wb_size);
 
 		// Dump package1.1.
 		emmcsn_path_impl(path, "/pkg1", "pkg1_decr.bin", &storage);
 		if (sd_save_to_file(pkg1, 0x40000, path))
 			goto out_free;
-		gfx_puts(&gfx_con, "\npkg1 dumped to pkg1_decr.bin\n");
+		gfx_puts("\npkg1 dumped to pkg1_decr.bin\n");
 	
 		// Dump nxbootloader.
 		emmcsn_path_impl(path, "/pkg1", "nxloader.bin", &storage);
 		if (sd_save_to_file(loader, hdr->ldr_size, path))
 			goto out_free;
-		gfx_puts(&gfx_con, "NX Bootloader dumped to nxloader.bin\n");
+		gfx_puts("NX Bootloader dumped to nxloader.bin\n");
 	
 		// Dump secmon.
 		emmcsn_path_impl(path, "/pkg1", "secmon.bin", &storage);
 		if (sd_save_to_file(secmon, hdr->sm_size, path))
 			goto out_free;
-		gfx_puts(&gfx_con, "Secure Monitor dumped to secmon.bin\n");
+		gfx_puts("Secure Monitor dumped to secmon.bin\n");
 	
 		// Dump warmboot.
 		emmcsn_path_impl(path, "/pkg1", "warmboot.bin", &storage);
 		if (sd_save_to_file(warmboot, hdr->wb_size, path))
 			goto out_free;
-		gfx_puts(&gfx_con, "Warmboot dumped to warmboot.bin\n\n\n");
+		gfx_puts("Warmboot dumped to warmboot.bin\n\n\n");
 	}
 
 	// Dump package2.1.
@@ -185,30 +185,30 @@ void dump_packages12()
 
 	// Display info.
 	u32 kernel_crc32 = crc32c(pkg2_hdr->data, pkg2_hdr->sec_size[PKG2_SEC_KERNEL]);
-	gfx_printf(&gfx_con, "\n%kKernel CRC32C: %k0x%08X\n\n", 0xFFC7EA46, 0xFFCCCCCC, kernel_crc32);
-	gfx_printf(&gfx_con, "%kKernel size:   %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, pkg2_hdr->sec_size[PKG2_SEC_KERNEL]);
-	gfx_printf(&gfx_con, "%kINI1 size:     %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, pkg2_hdr->sec_size[PKG2_SEC_INI1]);
+	gfx_printf("\n%kKernel CRC32C: %k0x%08X\n\n", 0xFFC7EA46, 0xFFCCCCCC, kernel_crc32);
+	gfx_printf("%kKernel size:   %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, pkg2_hdr->sec_size[PKG2_SEC_KERNEL]);
+	gfx_printf("%kINI1 size:     %k0x%05X\n\n", 0xFFC7EA46, 0xFFCCCCCC, pkg2_hdr->sec_size[PKG2_SEC_INI1]);
 
 	// Dump pkg2.1.
 	emmcsn_path_impl(path, "/pkg2", "pkg2_decr.bin", &storage);
 	if (sd_save_to_file(pkg2, pkg2_hdr->sec_size[PKG2_SEC_KERNEL] + pkg2_hdr->sec_size[PKG2_SEC_INI1], path))
 		goto out;
-	gfx_puts(&gfx_con, "\npkg2 dumped to pkg2_decr.bin\n");
+	gfx_puts("\npkg2 dumped to pkg2_decr.bin\n");
 
 	// Dump kernel.
 	emmcsn_path_impl(path, "/pkg2", "kernel.bin", &storage);
 	if (sd_save_to_file(pkg2_hdr->data, pkg2_hdr->sec_size[PKG2_SEC_KERNEL], path))
 		goto out;
-	gfx_puts(&gfx_con, "Kernel dumped to kernel.bin\n");
+	gfx_puts("Kernel dumped to kernel.bin\n");
 
 	// Dump INI1.
 	emmcsn_path_impl(path, "/pkg2", "ini1.bin", &storage);
 	if (sd_save_to_file(pkg2_hdr->data + pkg2_hdr->sec_size[PKG2_SEC_KERNEL],
 		pkg2_hdr->sec_size[PKG2_SEC_INI1], path))
 		goto out;
-	gfx_puts(&gfx_con, "INI1 dumped to ini1.bin\n");
+	gfx_puts("INI1 dumped to ini1.bin\n");
 
-	gfx_puts(&gfx_con, "\nDone. Press any key...\n");
+	gfx_puts("\nDone. Press any key...\n");
 
 out:
 	nx_emmc_gpt_free(&gpt);
@@ -234,8 +234,8 @@ void _toggle_autorcm(bool enable)
 
 	u8 randomXor = 0;
 
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	if (!sdmmc_storage_init_mmc(&storage, &sdmmc, SDMMC_4, SDMMC_BUS_WIDTH_8, 4))
 	{
@@ -270,10 +270,10 @@ void _toggle_autorcm(bool enable)
 	sdmmc_storage_end(&storage);
 
 	if (enable)
-		gfx_printf(&gfx_con, "%kAutoRCM mode enabled!%k", 0xFFFFBA00, 0xFFCCCCCC);
+		gfx_printf("%kAutoRCM mode enabled!%k", 0xFFFFBA00, 0xFFCCCCCC);
 	else
-		gfx_printf(&gfx_con, "%kAutoRCM mode disabled!%k", 0xFF96FF00, 0xFFCCCCCC);
-	gfx_printf(&gfx_con, "\n\nPress any key...\n");
+		gfx_printf("%kAutoRCM mode disabled!%k", 0xFF96FF00, 0xFFCCCCCC);
+	gfx_printf("\n\nPress any key...\n");
 
 out:
 	btn_wait();
@@ -284,8 +284,8 @@ void _disable_autorcm() { _toggle_autorcm(false); }
 
 void menu_autorcm()
 {
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	// Do a simple check on the main BCT.
 	sdmmc_storage_t storage;
@@ -340,7 +340,7 @@ void menu_autorcm()
 	memset(&ments[5], 0, sizeof(ment_t));
 	menu_t menu = {ments, "This corrupts your BOOT0!", 0, 0};
 
-	tui_do_menu(&gfx_con, &menu);
+	tui_do_menu(&menu);
 }
 
 int _fix_attributes(char *path, u32 *total, u32 hos_folder, u32 check_first_run)
@@ -421,8 +421,8 @@ int _fix_attributes(char *path, u32 *total, u32 hos_folder, u32 check_first_run)
 
 void _fix_sd_attr(u32 type)
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	char path[256];
 	char label[16];
@@ -443,9 +443,9 @@ void _fix_sd_attr(u32 type)
 			break;
 		}
 
-		gfx_printf(&gfx_con, "Traversing all %s files!\nThis may take some time...\n\n", label);
+		gfx_printf("Traversing all %s files!\nThis may take some time...\n\n", label);
 		_fix_attributes(path, &total, type, type);
-		gfx_printf(&gfx_con, "%kTotal archive bits cleared: %d!%k\n\nDone! Press any key...", 0xFF96FF00, total, 0xFFCCCCCC);
+		gfx_printf("%kTotal archive bits cleared: %d!%k\n\nDone! Press any key...", 0xFF96FF00, total, 0xFFCCCCCC);
 		sd_unmount();
 	}
 	btn_wait();
@@ -456,20 +456,20 @@ void fix_sd_nin_attr() { _fix_sd_attr(1); }
 
 void fix_battery_desync()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	max77620_low_battery_monitor_config();
 
-	gfx_puts(&gfx_con, "\nDone!\n");
+	gfx_puts("\nDone!\n");
 
 	btn_wait();
 }
 
 /* void fix_fuel_gauge_configuration()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	int battVoltage, avgCurrent;
 
@@ -483,23 +483,23 @@ void fix_battery_desync()
 			EPRINTF("You need to be connected to a wall adapter,\nto apply this fix!");
 		else
 		{
-			gfx_printf(&gfx_con, "%kAre you really sure?\nThis will reset your fuel gauge completely!\n", 0xFFFFDD00);
-			gfx_printf(&gfx_con, "Additionally this will power off your console.\n%k", 0xFFCCCCCC);
+			gfx_printf("%kAre you really sure?\nThis will reset your fuel gauge completely!\n", 0xFFFFDD00);
+			gfx_printf("Additionally this will power off your console.\n%k", 0xFFCCCCCC);
 
-			gfx_puts(&gfx_con, "\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
+			gfx_puts("\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
 
 			u32 btn = btn_wait();
 			if (btn & BTN_POWER)
 			{
 				max17050_fix_configuration();
 				msleep(1000);
-				gfx_con_getpos(&gfx_con, &gfx_con.savedx,  &gfx_con.savedy);
+				gfx_con_getpos(&gfx_con.savedx,  &gfx_con.savedy);
 				u16 value = 0;
-				gfx_printf(&gfx_con, "%kThe console will power off in 45 seconds.\n%k", 0xFFFFDD00, 0xFFCCCCCC);
+				gfx_printf("%kThe console will power off in 45 seconds.\n%k", 0xFFFFDD00, 0xFFCCCCCC);
 				while (value < 46)
 				{
-					gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-					gfx_printf(&gfx_con, "%2ds elapsed", value);
+					gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+					gfx_printf("%2ds elapsed", value);
 					msleep(1000);
 					value++;
 				}
@@ -521,31 +521,31 @@ void fix_battery_desync()
 {
 	int avgCurrent;
 
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
-	gfx_printf(&gfx_con, "%k\nThis will wipe your battery stats completely!\n"
+	gfx_printf("%k\nThis will wipe your battery stats completely!\n"
 		"%kAnd it may not power on without physically\nremoving and re-inserting the battery.\n%k"
 		"\nAre you really sure?%k\n", 0xFFFFDD00, 0xFFFF0000, 0xFFFFDD00, 0xFFCCCCCC);
 
-	gfx_puts(&gfx_con, "\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
+	gfx_puts("\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n\n");
 	u32 btn = btn_wait();
 	if (btn & BTN_POWER)
 	{
-		gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-		gfx_con_setpos(&gfx_con, 0, 0);
-		gfx_printf(&gfx_con, "%kKeep the USB cable connected!%k\n\n", 0xFFFFDD00, 0xFFCCCCCC);
-		gfx_con_getpos(&gfx_con, &gfx_con.savedx,  &gfx_con.savedy);
+		gfx_clear_partial_grey(0x1B, 0, 1256);
+		gfx_con_setpos(0, 0);
+		gfx_printf("%kKeep the USB cable connected!%k\n\n", 0xFFFFDD00, 0xFFCCCCCC);
+		gfx_con_getpos(&gfx_con.savedx,  &gfx_con.savedy);
 
 		u8 value = 30;
 		while (value > 0)
 		{
-			gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
-			gfx_printf(&gfx_con, "%kWait... (%ds)   %k", 0xFF888888, value, 0xFFCCCCCC);
+			gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
+			gfx_printf("%kWait... (%ds)   %k", 0xFF888888, value, 0xFFCCCCCC);
 			msleep(1000);
 			value--;
 		}
-		gfx_con_setpos(&gfx_con, gfx_con.savedx, gfx_con.savedy);
+		gfx_con_setpos(gfx_con.savedx, gfx_con.savedy);
 
 		//Check if still connected.
 		max17050_get_property(MAX17050_AvgCurrent, &avgCurrent);
@@ -555,7 +555,7 @@ void fix_battery_desync()
 		{
 			// Apply fix.
 			bq24193_fake_battery_removal();
-			gfx_printf(&gfx_con, "Done!               \n"
+			gfx_printf("Done!               \n"
 				"%k1. Remove the USB cable\n"
 				"2. Press POWER for 15s.\n"
 				"3. Reconnect the USB to power-on!%k\n", 0xFFFFDD00, 0xFFCCCCCC);
@@ -573,22 +573,22 @@ void fix_battery_desync()
 
 void minerva()
 {
-	gfx_clear_partial_grey(&gfx_ctxt, 0x1B, 0, 1256);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	gfx_con_setpos(0, 0);
 
 	u32 curr_ram_idx = 0;
 
 	if (!sd_mount())
 		return;
 
-	gfx_printf(&gfx_con, "-- Minerva Training Cell --\n\n");
+	gfx_printf("-- Minerva Training Cell --\n\n");
 
 	// Set table to ram.
 	mtc_cfg.mtc_table = NULL;
 	mtc_cfg.sdram_id = (fuse_read_odm(4) >> 3) & 0x1F;
 	ianos_loader(false, "bootloader/sys/libsys_minerva.bso", DRAM_LIB, (void *)&mtc_cfg);
 
-	gfx_printf(&gfx_con, "\nStarting training process..\n\n");
+	gfx_printf("\nStarting training process..\n\n");
 
 	// Get current frequency
 	for (curr_ram_idx = 0; curr_ram_idx < 10; curr_ram_idx++)
@@ -603,21 +603,21 @@ void minerva()
 	mtc_cfg.rate_from = mtc_cfg.mtc_table[curr_ram_idx].rate_khz;
 	mtc_cfg.rate_to = 800000;
 	mtc_cfg.train_mode = OP_TRAIN_SWITCH;
-	gfx_printf(&gfx_con, "Training and switching %7d -> %7d\n\n", mtc_cfg.mtc_table[curr_ram_idx].rate_khz, 800000);
+	gfx_printf("Training and switching %7d -> %7d\n\n", mtc_cfg.mtc_table[curr_ram_idx].rate_khz, 800000);
 	ianos_loader(false, "bootloader/sys/libsys_minerva.bso", DRAM_LIB, (void *)&mtc_cfg);
 	
 	// Thefollowing frequency needs periodic training every 100ms.
 	//msleep(200);
 
 	//mtc_cfg.rate_to = 1600000;
-	//gfx_printf(&gfx_con, "Training and switching  %7d -> %7d\n\n", mtc_cfg.current_emc_table->rate_khz, 1600000);
+	//gfx_printf("Training and switching  %7d -> %7d\n\n", mtc_cfg.current_emc_table->rate_khz, 1600000);
 	//ianos_loader(false, "bootloader/sys/libsys_minerva.bso", DRAM_LIB, (void *)&mtc_cfg);
 
 	//mtc_cfg.train_mode = OP_PERIODIC_TRAIN;
 	
 	sd_unmount();
 	
-	gfx_printf(&gfx_con, "Finished!");
+	gfx_printf("Finished!");
 
 	btn_wait();
 }
diff --git a/bootloader/gfx/gfx.c b/bootloader/gfx/gfx.c
index 68aee79..a95349b 100644
--- a/bootloader/gfx/gfx.c
+++ b/bootloader/gfx/gfx.c
@@ -117,73 +117,73 @@ static const u8 _gfx_font[] = {
 	0x00, 0x00, 0x00, 0x4C, 0x32, 0x00, 0x00, 0x00  // Char 126 (~)
 };
 
-void gfx_init_ctxt(gfx_ctxt_t *ctxt, u32 *fb, u32 width, u32 height, u32 stride)
+void gfx_init_ctxt(u32 *fb, u32 width, u32 height, u32 stride)
 {
-	ctxt->fb = fb;
-	ctxt->width = width;
-	ctxt->height = height;
-	ctxt->stride = stride;
+	gfx_ctxt.fb = fb;
+	gfx_ctxt.width = width;
+	gfx_ctxt.height = height;
+	gfx_ctxt.stride = stride;
 }
 
-void gfx_clear_grey(gfx_ctxt_t *ctxt, u8 color)
+void gfx_clear_grey(u8 color)
 {
-	memset(ctxt->fb, color, 0x3C0000);
+	memset(gfx_ctxt.fb, color, 0x3C0000);
 }
 
-void gfx_clear_color(gfx_ctxt_t *ctxt, u32 color)
+void gfx_clear_color(u32 color)
 {
-	for (u32 i = 0; i < ctxt->height * ctxt->stride; i++)
-		ctxt->fb[i] = color;
+	for (u32 i = 0; i < gfx_ctxt.height * gfx_ctxt.stride; i++)
+		gfx_ctxt.fb[i] = color;
 }
 
-void gfx_clear_partial_grey(gfx_ctxt_t *ctxt, u8 color, u32 pos_x, u32 height)
+void gfx_clear_partial_grey(u8 color, u32 pos_x, u32 height)
 {
-	memset(ctxt->fb + pos_x * ctxt->stride, color, height * 4 * ctxt->stride);
+	memset(gfx_ctxt.fb + pos_x * gfx_ctxt.stride, color, height * 4 * gfx_ctxt.stride);
 }
 
-void gfx_con_init(gfx_con_t *con, gfx_ctxt_t *ctxt)
+void gfx_con_init()
 {
-	con->gfx_ctxt = ctxt;
-	con->fntsz = 16;
-	con->x = 0;
-	con->y = 0;
-	con->savedx = 0;
-	con->savedy = 0;
-	con->fgcol = 0xFFCCCCCC;
-	con->fillbg = 0;
-	con->bgcol = 0xFF1B1B1B;
-	con->mute = 0;
+	gfx_con.gfx_ctxt = &gfx_ctxt;
+	gfx_con.fntsz = 16;
+	gfx_con.x = 0;
+	gfx_con.y = 0;
+	gfx_con.savedx = 0;
+	gfx_con.savedy = 0;
+	gfx_con.fgcol = 0xFFCCCCCC;
+	gfx_con.fillbg = 0;
+	gfx_con.bgcol = 0xFF1B1B1B;
+	gfx_con.mute = 0;
 }
 
-void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol)
+void gfx_con_setcol(u32 fgcol, int fillbg, u32 bgcol)
 {
-	con->fgcol = fgcol;
-	con->fillbg = fillbg;
-	con->bgcol = bgcol;
+	gfx_con.fgcol = fgcol;
+	gfx_con.fillbg = fillbg;
+	gfx_con.bgcol = bgcol;
 }
 
-void gfx_con_getpos(gfx_con_t *con, u32 *x, u32 *y)
+void gfx_con_getpos(u32 *x, u32 *y)
 {
-	*x = con->x;
-	*y = con->y;
+	*x = gfx_con.x;
+	*y = gfx_con.y;
 }
 
-void gfx_con_setpos(gfx_con_t *con, u32 x, u32 y)
+void gfx_con_setpos(u32 x, u32 y)
 {
-	con->x = x;
-	con->y = y;
+	gfx_con.x = x;
+	gfx_con.y = y;
 }
 
-void gfx_putc(gfx_con_t *con, char c)
+void gfx_putc(char c)
 {
 	// Duplicate code for performance reasons.
-	switch (con->fntsz)
+	switch (gfx_con.fntsz)
 	{
 	case 16:
 		if (c >= 32 && c <= 126)
 		{
 			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
-			u32 *fb = con->gfx_ctxt->fb + con->x + con->y * con->gfx_ctxt->stride;
+			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
 
 			for (u32 i = 0; i < 16; i+=2)
 			{
@@ -194,33 +194,33 @@ void gfx_putc(gfx_con_t *con, char c)
 					{
 						if (v & 1)
 						{
-							*fb = con->fgcol;
+							*fb = gfx_con.fgcol;
 							fb++;
-							*fb = con->fgcol;
+							*fb = gfx_con.fgcol;
 						}
-						else if (con->fillbg)
+						else if (gfx_con.fillbg)
 						{
-							*fb = con->bgcol;
+							*fb = gfx_con.bgcol;
 							fb++;
-							*fb = con->bgcol;
+							*fb = gfx_con.bgcol;
 						}
 						else
 							fb++;
 						v >>= 1;
 						fb++;
 					}
-					fb += con->gfx_ctxt->stride - 16;
+					fb += gfx_ctxt.stride - 16;
 					v = *cbuf;
 				}
 			}
-			con->x += 16;
+			gfx_con.x += 16;
 		}
 		else if (c == '\n')
 		{
-			con->x = 0;
-			con->y +=16;
-			if (con->y > con->gfx_ctxt->height - 16)
-				con->y = 0;
+			gfx_con.x = 0;
+			gfx_con.y +=16;
+			if (gfx_con.y > gfx_ctxt.height - 16)
+				gfx_con.y = 0;
 		}
 		break;
 	case 8:
@@ -228,45 +228,45 @@ void gfx_putc(gfx_con_t *con, char c)
 		if (c >= 32 && c <= 126)
 		{
 			u8 *cbuf = (u8 *)&_gfx_font[8 * (c - 32)];
-			u32 *fb = con->gfx_ctxt->fb + con->x + con->y * con->gfx_ctxt->stride;
+			u32 *fb = gfx_ctxt.fb + gfx_con.x + gfx_con.y * gfx_ctxt.stride;
 			for (u32 i = 0; i < 8; i++)
 			{
 				u8 v = *cbuf++;
 				for (u32 j = 0; j < 8; j++)
 				{
 					if (v & 1)
-						*fb = con->fgcol;
-					else if (con->fillbg)
-						*fb = con->bgcol;
+						*fb = gfx_con.fgcol;
+					else if (gfx_con.fillbg)
+						*fb = gfx_con.bgcol;
 					v >>= 1;
 					fb++;
 				}
-				fb += con->gfx_ctxt->stride - 8;
+				fb += gfx_ctxt.stride - 8;
 			}
-			con->x += 8;
+			gfx_con.x += 8;
 		}
 		else if (c == '\n')
 		{
-			con->x = 0;
-			con->y += 8;
-			if (con->y > con->gfx_ctxt->height - 8)
-				con->y = 0;
+			gfx_con.x = 0;
+			gfx_con.y += 8;
+			if (gfx_con.y > gfx_ctxt.height - 8)
+				gfx_con.y = 0;
 		}
 		break;
 	}
 	
 }
 
-void gfx_puts(gfx_con_t *con, const char *s)
+void gfx_puts(const char *s)
 {
-	if (!s || con->mute)
+	if (!s || gfx_con.mute)
 		return;
 
 	for (; *s; s++)
-		gfx_putc(con, *s);
+		gfx_putc(*s);
 }
 
-static void _gfx_putn(gfx_con_t *con, u32 v, int base, char fill, int fcnt)
+static void _gfx_putn(u32 v, int base, char fill, int fcnt)
 {
 	char buf[65];
 	static const char digits[] = "0123456789ABCDEFghijklmnopqrstuvwxyz";
@@ -294,28 +294,28 @@ static void _gfx_putn(gfx_con_t *con, u32 v, int base, char fill, int fcnt)
 		}
 	}
 
-	gfx_puts(con, p);
+	gfx_puts(p);
 }
 
 void gfx_put_small_sep(gfx_con_t *con)
 {
-	u8 prevFontSize = con->fntsz;
-	con->fntsz = 8;
-	gfx_putc(con, '\n');
-	con->fntsz = prevFontSize;
+	u8 prevFontSize = gfx_con.fntsz;
+	gfx_con.fntsz = 8;
+	gfx_putc('\n');
+	gfx_con.fntsz = prevFontSize;
 }
 
 void gfx_put_big_sep(gfx_con_t *con)
 {
-	u8 prevFontSize = con->fntsz;
-	con->fntsz = 16;
-	gfx_putc(con, '\n');
-	con->fntsz = prevFontSize;
+	u8 prevFontSize = gfx_con.fntsz;
+	gfx_con.fntsz = 16;
+	gfx_putc('\n');
+	gfx_con.fntsz = prevFontSize;
 }
 
-void gfx_printf(gfx_con_t *con, const char *fmt, ...)
+void gfx_printf(const char *fmt, ...)
 {
-	if (con->mute)
+	if (gfx_con.mute)
 		return;
 
 	va_list ap;
@@ -348,40 +348,40 @@ void gfx_printf(gfx_con_t *con, const char *fmt, ...)
 			switch(*fmt)
 			{
 			case 'c':
-				gfx_putc(con, va_arg(ap, u32));
+				gfx_putc(va_arg(ap, u32));
 				break;
 			case 's':
-				gfx_puts(con, va_arg(ap, char *));
+				gfx_puts(va_arg(ap, char *));
 				break;
 			case 'd':
-				_gfx_putn(con, va_arg(ap, u32), 10, fill, fcnt);
+				_gfx_putn(va_arg(ap, u32), 10, fill, fcnt);
 				break;
 			case 'p':
 			case 'P':
 			case 'x':
 			case 'X':
-				_gfx_putn(con, va_arg(ap, u32), 16, fill, fcnt);
+				_gfx_putn(va_arg(ap, u32), 16, fill, fcnt);
 				break;
 			case 'k':
-				con->fgcol = va_arg(ap, u32);
+				gfx_con.fgcol = va_arg(ap, u32);
 				break;
 			case 'K':
-				con->bgcol = va_arg(ap, u32);
-				con->fillbg = 1;
+				gfx_con.bgcol = va_arg(ap, u32);
+				gfx_con.fillbg = 1;
 				break;
 			case '%':
-				gfx_putc(con, '%');
+				gfx_putc('%');
 				break;
 			case '\0':
 				goto out;
 			default:
-				gfx_putc(con, '%');
-				gfx_putc(con, *fmt);
+				gfx_putc('%');
+				gfx_putc(*fmt);
 				break;
 			}
 		}
 		else
-			gfx_putc(con, *fmt);
+			gfx_putc(*fmt);
 		fmt++;
 	}
 
@@ -389,33 +389,33 @@ void gfx_printf(gfx_con_t *con, const char *fmt, ...)
 	va_end(ap);
 }
 
-void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len)
+void gfx_hexdump(u32 base, const u8 *buf, u32 len)
 {
-	if (con->mute)
+	if (gfx_con.mute)
 		return;
 
-	u8 prevFontSize = con->fntsz;
-	con->fntsz = 8;
+	u8 prevFontSize = gfx_con.fntsz;
+	gfx_con.fntsz = 8;
 	for(u32 i = 0; i < len; i++)
 	{
 		if(i % 0x10 == 0)
 		{
 			if(i != 0)
 			{
-				gfx_puts(con, "| ");
+				gfx_puts("| ");
 				for(u32 j = 0; j < 0x10; j++)
 				{
 					u8 c = buf[i - 0x10 + j];
 					if(c >= 32 && c <= 126)
-						gfx_putc(con, c);
+						gfx_putc(c);
 					else
-						gfx_putc(con, '.');
+						gfx_putc('.');
 				}
-				gfx_putc(con, '\n');
+				gfx_putc('\n');
 			}
-			gfx_printf(con, "%08x: ", base + i);
+			gfx_printf("%08x: ", base + i);
 		}
-		gfx_printf(con, "%02x ", buf[i]);
+		gfx_printf("%02x ", buf[i]);
 		if (i == len - 1)
 		{
 			int ln = len % 0x10 != 0;
@@ -424,22 +424,22 @@ void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len)
 			{
 				k = (len & 0xF) - 1;
 				for (u32 j = 0; j < 0x10 - k; j++)
-					gfx_puts(con, "   ");
+					gfx_puts("   ");
 			}
-			gfx_puts(con, "| ");
+			gfx_puts("| ");
 			for(u32 j = 0; j < (ln ? k : k + 1); j++)
 			{
 				u8 c = buf[i - k + j];
 				if(c >= 32 && c <= 126)
-					gfx_putc(con, c);
+					gfx_putc(c);
 				else
-					gfx_putc(con, '.');
+					gfx_putc('.');
 			}
-			gfx_putc(con, '\n');
+			gfx_putc('\n');
 		}
 	}
-	gfx_putc(con, '\n');
-	con->fntsz = prevFontSize;
+	gfx_putc('\n');
+	gfx_con.fntsz = prevFontSize;
 }
 
 static int abs(int x)
@@ -449,12 +449,12 @@ static int abs(int x)
 	return x;
 }
 
-void gfx_set_pixel(gfx_ctxt_t *ctxt, u32 x, u32 y, u32 color)
+void gfx_set_pixel(u32 x, u32 y, u32 color)
 {
-	ctxt->fb[x + y * ctxt->stride] = color;
+	gfx_ctxt.fb[x + y * gfx_ctxt.stride] = color;
 }
 
-void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color)
+void gfx_line(int x0, int y0, int x1, int y1, u32 color)
 {
 	int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
 	int dy = abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
@@ -462,7 +462,7 @@ void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color)
 
 	while (1)
 	{
-		gfx_set_pixel(ctxt, x0, y0, color);
+		gfx_set_pixel(x0, y0, color);
 		if (x0 == x1 && y0 == y1)
 			break;
 		e2 = err;
@@ -479,46 +479,46 @@ void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color)
 	}
 }
 
-void gfx_set_rect_grey(gfx_ctxt_t *ctxt, const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
+void gfx_set_rect_grey(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
 {
 	u32 pos = 0;
 	for (u32 y = pos_y; y < (pos_y + size_y); y++)
 	{
 		for (u32 x = pos_x; x < (pos_x + size_x); x++)
 		{
-			memset(&ctxt->fb[x + y*ctxt->stride], buf[pos], 4);
+			memset(&gfx_ctxt.fb[x + y*gfx_ctxt.stride], buf[pos], 4);
 			pos++;
 		}
 	}
 }
 
 
-void gfx_set_rect_rgb(gfx_ctxt_t *ctxt, const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
+void gfx_set_rect_rgb(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
 {
 	u32 pos = 0;
 	for (u32 y = pos_y; y < (pos_y + size_y); y++)
 	{
 		for (u32 x = pos_x; x < (pos_x + size_x); x++)
 		{
-			ctxt->fb[x + y*ctxt->stride] = buf[pos + 2] | (buf[pos + 1] << 8) | (buf[pos] << 16);
+			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = buf[pos + 2] | (buf[pos + 1] << 8) | (buf[pos] << 16);
 			pos+=3;
 		}
 	}
 }
 
-void gfx_set_rect_argb(gfx_ctxt_t *ctxt, const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
+void gfx_set_rect_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
 {
 	u32 *ptr = (u32 *)buf;
 	for (u32 y = pos_y; y < (pos_y + size_y); y++)
 		for (u32 x = pos_x; x < (pos_x + size_x); x++)
-			ctxt->fb[x + y * ctxt->stride] = *ptr++;
+			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = *ptr++;
 }
 
-void gfx_render_bmp_argb(gfx_ctxt_t *ctxt, const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
+void gfx_render_bmp_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y)
 {
 	for (u32 y = pos_y; y < (pos_y + size_y); y++)
 	{
 		for (u32 x = pos_x; x < (pos_x + size_x); x++)
-			ctxt->fb[x + y * ctxt->stride] = buf[(size_y + pos_y - 1 - y ) * size_x + x - pos_x];
+			gfx_ctxt.fb[x + y * gfx_ctxt.stride] = buf[(size_y + pos_y - 1 - y ) * size_x + x - pos_x];
 	}
 }
diff --git a/bootloader/gfx/gfx.h b/bootloader/gfx/gfx.h
index d2bb614..6e4137d 100644
--- a/bootloader/gfx/gfx.h
+++ b/bootloader/gfx/gfx.h
@@ -21,32 +21,32 @@
 
 #include "../../common/common_gfx.h"
 
-#define EPRINTF(text) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFFFF0000, 0xFFCCCCCC)
-#define EPRINTFARGS(text, args...) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFFFF0000, args, 0xFFCCCCCC)
-#define WPRINTF(text) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFFFFDD00, 0xFFCCCCCC)
-#define WPRINTFARGS(text, args...) gfx_printf(&gfx_con, "%k"text"%k\n", 0xFFFFDD00, args, 0xFFCCCCCC)
+#define EPRINTF(text) gfx_printf("%k"text"%k\n", 0xFFFF0000, 0xFFCCCCCC)
+#define EPRINTFARGS(text, args...) gfx_printf("%k"text"%k\n", 0xFFFF0000, args, 0xFFCCCCCC)
+#define WPRINTF(text) gfx_printf("%k"text"%k\n", 0xFFFFDD00, 0xFFCCCCCC)
+#define WPRINTFARGS(text, args...) gfx_printf("%k"text"%k\n", 0xFFFFDD00, args, 0xFFCCCCCC)
 
-void gfx_init_ctxt(gfx_ctxt_t *ctxt, u32 *fb, u32 width, u32 height, u32 stride);
-void gfx_clear_grey(gfx_ctxt_t *ctxt, u8 color);
-void gfx_clear_partial_grey(gfx_ctxt_t *ctxt, u8 color, u32 pos_x, u32 height);
-void gfx_clear_color(gfx_ctxt_t *ctxt, u32 color);
-void gfx_con_init(gfx_con_t *con, gfx_ctxt_t *ctxt);
-void gfx_con_setcol(gfx_con_t *con, u32 fgcol, int fillbg, u32 bgcol);
-void gfx_con_getpos(gfx_con_t *con, u32 *x, u32 *y);
-void gfx_con_setpos(gfx_con_t *con, u32 x, u32 y);
-void gfx_putc(gfx_con_t *con, char c);
-void gfx_puts(gfx_con_t *con, const char *s);
-void gfx_printf(gfx_con_t *con, const char *fmt, ...);
-void gfx_hexdump(gfx_con_t *con, u32 base, const u8 *buf, u32 len);
+void gfx_init_ctxt(u32 *fb, u32 width, u32 height, u32 stride);
+void gfx_clear_grey(u8 color);
+void gfx_clear_partial_grey(u8 color, u32 pos_x, u32 height);
+void gfx_clear_color(u32 color);
+void gfx_con_init();
+void gfx_con_setcol(u32 fgcol, int fillbg, u32 bgcol);
+void gfx_con_getpos(u32 *x, u32 *y);
+void gfx_con_setpos(u32 x, u32 y);
+void gfx_putc(char c);
+void gfx_puts(const char *s);
+void gfx_printf(const char *fmt, ...);
+void gfx_hexdump(u32 base, const u8 *buf, u32 len);
 
-void gfx_set_pixel(gfx_ctxt_t *ctxt, u32 x, u32 y, u32 color);
-void gfx_line(gfx_ctxt_t *ctxt, int x0, int y0, int x1, int y1, u32 color);
+void gfx_set_pixel(u32 x, u32 y, u32 color);
+void gfx_line(int x0, int y0, int x1, int y1, u32 color);
 void gfx_put_small_sep(gfx_con_t *con);
 void gfx_put_big_sep(gfx_con_t *con);
-void gfx_set_rect_grey(gfx_ctxt_t *ctxt, const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
-void gfx_set_rect_rgb(gfx_ctxt_t *ctxt, const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
-void gfx_set_rect_argb(gfx_ctxt_t *ctxt, const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
-void gfx_render_bmp_argb(gfx_ctxt_t *ctxt, const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
+void gfx_set_rect_grey(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
+void gfx_set_rect_rgb(const u8 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
+void gfx_set_rect_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
+void gfx_render_bmp_argb(const u32 *buf, u32 size_x, u32 size_y, u32 pos_x, u32 pos_y);
 
 // Global gfx console and context.
 gfx_ctxt_t gfx_ctxt;
diff --git a/bootloader/gfx/tui.c b/bootloader/gfx/tui.c
index eba06db..3ab56a2 100644
--- a/bootloader/gfx/tui.c
+++ b/bootloader/gfx/tui.c
@@ -32,7 +32,7 @@ extern u8 *Kc_MENU_LOGO;
 
 extern hekate_config h_cfg;
 
-void tui_sbar(gfx_con_t *con, bool force_update)
+void tui_sbar(bool force_update)
 {
 	u32 cx, cy;
 
@@ -41,78 +41,78 @@ void tui_sbar(gfx_con_t *con, bool force_update)
 		if (timePassed < 5)
 			return;
 
-	u8 prevFontSize = con->fntsz;
-	con->fntsz = 16;
+	u8 prevFontSize = gfx_con.fntsz;
+	gfx_con.fntsz = 16;
 	h_cfg.sbar_time_keeping = get_tmr_s();
 
 	u32 battPercent = 0;
 	int battVoltCurr = 0;
 
-	gfx_con_getpos(con, &cx, &cy);
-	gfx_con_setpos(con, 0,  1260);
+	gfx_con_getpos(&cx, &cy);
+	gfx_con_setpos(0,  1260);
 
 	max17050_get_property(MAX17050_RepSOC, (int *)&battPercent);
 	max17050_get_property(MAX17050_VCELL, &battVoltCurr);
 
-	gfx_clear_partial_grey(con->gfx_ctxt, 0x30, 1256, 24);
-	gfx_printf(con, "%K%k Battery: %d.%d%% (%d mV) - Charge:", 0xFF303030, 0xFF888888,
+	gfx_clear_partial_grey(0x30, 1256, 24);
+	gfx_printf("%K%k Battery: %d.%d%% (%d mV) - Charge:", 0xFF303030, 0xFF888888,
 		(battPercent >> 8) & 0xFF, (battPercent & 0xFF) / 26, battVoltCurr);
 
-	max17050_get_property(MAX17050_AvgCurrent, &battVoltCurr);
+	max17050_get_property(MAX17050_Current, &battVoltCurr);
 
 	if (battVoltCurr >= 0)
-		gfx_printf(con, " %k+%d mA%k%K\n",
+		gfx_printf(" %k+%d mA%k%K\n",
 			0xFF008800, battVoltCurr / 1000, 0xFFCCCCCC, 0xFF1B1B1B);
 	else
-		gfx_printf(con, " %k-%d mA%k%K\n",
+		gfx_printf(" %k-%d mA%k%K\n",
 			0xFF880000, (~battVoltCurr) / 1000, 0xFFCCCCCC, 0xFF1B1B1B);
-	con->fntsz = prevFontSize;
-	gfx_con_setpos(con, cx, cy);
+	gfx_con.fntsz = prevFontSize;
+	gfx_con_setpos(cx, cy);
 }
 
-void tui_pbar(gfx_con_t *con, int x, int y, u32 val, u32 fgcol, u32 bgcol)
+void tui_pbar(int x, int y, u32 val, u32 fgcol, u32 bgcol)
 {
 	u32 cx, cy;
 	if (val > 200)
 		val = 200;
 
-	gfx_con_getpos(con, &cx, &cy);
+	gfx_con_getpos(&cx, &cy);
 
-	gfx_con_setpos(con, x, y);
+	gfx_con_setpos(x, y);
 
-	gfx_printf(con, "%k[%3d%%]%k", fgcol, val, 0xFFCCCCCC);
+	gfx_printf("%k[%3d%%]%k", fgcol, val, 0xFFCCCCCC);
 
-	x += 7 * con->fntsz;
+	x += 7 * gfx_con.fntsz;
 	
-	for (int i = 0; i < (con->fntsz >> 3) * 6; i++)
+	for (int i = 0; i < (gfx_con.fntsz >> 3) * 6; i++)
 	{
-		gfx_line(con->gfx_ctxt, x, y + i + 1, x + 3 * val, y + i + 1, fgcol);
-		gfx_line(con->gfx_ctxt, x + 3 * val, y + i + 1, x + 3 * 100, y + i + 1, bgcol);
+		gfx_line(x, y + i + 1, x + 3 * val, y + i + 1, fgcol);
+		gfx_line(x + 3 * val, y + i + 1, x + 3 * 100, y + i + 1, bgcol);
 	}
 
-	gfx_con_setpos(con, cx, cy);
+	gfx_con_setpos(cx, cy);
 
 	// Update status bar.
-	tui_sbar(con, false);
+	tui_sbar(false);
 }
 
-void *tui_do_menu(gfx_con_t *con, menu_t *menu)
+void *tui_do_menu(menu_t *menu)
 {
 	int idx = 0, prev_idx = 0, cnt = 0x7FFFFFFF;
 
-	gfx_clear_partial_grey(con->gfx_ctxt, 0x1B, 0, 1256);
-	tui_sbar(con, true);
+	gfx_clear_partial_grey(0x1B, 0, 1256);
+	tui_sbar(true);
 
 #ifdef MENU_LOGO_ENABLE
-	gfx_set_rect_rgb(con->gfx_ctxt, Kc_MENU_LOGO,
+	gfx_set_rect_rgb(Kc_MENU_LOGO,
 		X_MENU_LOGO, Y_MENU_LOGO, X_POS_MENU_LOGO, Y_POS_MENU_LOGO);
 #endif //MENU_LOGO_ENABLE
 
 	while (true)
 	{
-		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
-		gfx_con_setpos(con, menu->x, menu->y);
-		gfx_printf(con, "[%s]\n\n", menu->caption);
+		gfx_con_setcol(0xFFCCCCCC, 1, 0xFF1B1B1B);
+		gfx_con_setpos(menu->x, menu->y);
+		gfx_printf("[%s]\n\n", menu->caption);
 
 		// Skip caption or seperator lines selection.
 		while (menu->ents[idx].type == MENT_CAPTION ||
@@ -143,30 +143,30 @@ void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 		for (cnt = 0; menu->ents[cnt].type != MENT_END; cnt++)
 		{
 			if (cnt == idx)
-				gfx_con_setcol(con, 0xFF1B1B1B, 1, 0xFFCCCCCC);
+				gfx_con_setcol(0xFF1B1B1B, 1, 0xFFCCCCCC);
 			else
-				gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
+				gfx_con_setcol(0xFFCCCCCC, 1, 0xFF1B1B1B);
 			if (menu->ents[cnt].type == MENT_CAPTION)
-				gfx_printf(con, "%k %s", menu->ents[cnt].color, menu->ents[cnt].caption);
+				gfx_printf("%k %s", menu->ents[cnt].color, menu->ents[cnt].caption);
 			else if (menu->ents[cnt].type != MENT_CHGLINE)
-				gfx_printf(con, " %s", menu->ents[cnt].caption);
+				gfx_printf(" %s", menu->ents[cnt].caption);
 			if(menu->ents[cnt].type == MENT_MENU)
-				gfx_printf(con, "%k...", 0xFF0099EE);
-			gfx_printf(con, " \n");
+				gfx_printf("%k...", 0xFF0099EE);
+			gfx_printf(" \n");
 		}
-		gfx_con_setcol(con, 0xFFCCCCCC, 1, 0xFF1B1B1B);
-		gfx_putc(con, '\n');
+		gfx_con_setcol(0xFFCCCCCC, 1, 0xFF1B1B1B);
+		gfx_putc('\n');
 
 		// Print help and battery status.
-		gfx_con_setpos(con, 0,  1127);
+		gfx_con_setpos(0,  1127);
 		if (h_cfg.errors)
 		{
-			gfx_printf(con, "%k Warning: %k", 0xFF800000, 0xFF555555);
+			gfx_printf("%k Warning: %k", 0xFF800000, 0xFF555555);
 			if (h_cfg.errors & ERR_LIBSYS_LP0)
-				gfx_printf(con, "Sleep mode library is missing!\n");
+				gfx_printf("Sleep mode library is missing!\n");
 		}
-		gfx_con_setpos(con, 0,  1191);
-		gfx_printf(con, "%k VOL: Move up/down\n PWR: Select option%k", 0xFF555555, 0xFFCCCCCC);
+		gfx_con_setpos(0,  1191);
+		gfx_printf("%k VOL: Move up/down\n PWR: Select option%k", 0xFF555555, 0xFFCCCCCC);
 
 		display_backlight_brightness(h_cfg.backlight, 1000);
 
@@ -196,7 +196,7 @@ void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 				ent->handler(ent->data);
 				break;
 			case MENT_MENU:
-				return tui_do_menu(con, ent->menu);
+				return tui_do_menu(ent->menu);
 				break;
 			case MENT_DATA:
 				return ent->data;
@@ -212,14 +212,14 @@ void *tui_do_menu(gfx_con_t *con, menu_t *menu)
 			default:
 				break;
 			}
-			con->fntsz = 16;
-			gfx_clear_partial_grey(con->gfx_ctxt, 0x1B, 0, 1256);
+			gfx_con.fntsz = 16;
+			gfx_clear_partial_grey(0x1B, 0, 1256);
 #ifdef MENU_LOGO_ENABLE
-			gfx_set_rect_rgb(con->gfx_ctxt, Kc_MENU_LOGO,
+			gfx_set_rect_rgb(Kc_MENU_LOGO,
 				X_MENU_LOGO, Y_MENU_LOGO, X_POS_MENU_LOGO, Y_POS_MENU_LOGO);
 #endif //MENU_LOGO_ENABLE
 		}
-		tui_sbar(con, false);
+		tui_sbar(false);
 	}
 
 	return NULL;
diff --git a/bootloader/gfx/tui.h b/bootloader/gfx/tui.h
index 3148ba3..819a5db 100644
--- a/bootloader/gfx/tui.h
+++ b/bootloader/gfx/tui.h
@@ -59,8 +59,8 @@ typedef struct _menu_t
 #define MDEF_CAPTION(caption, color) { MENT_CAPTION, caption, color }
 #define MDEF_CHGLINE() {MENT_CHGLINE}
 
-void tui_sbar(gfx_con_t *con, bool force_update);
-void tui_pbar(gfx_con_t *con, int x, int y, u32 val, u32 fgcol, u32 bgcol);
-void *tui_do_menu(gfx_con_t *con, menu_t *menu);
+void tui_sbar(bool force_update);
+void tui_pbar(int x, int y, u32 val, u32 fgcol, u32 bgcol);
+void *tui_do_menu(menu_t *menu);
 
 #endif
diff --git a/bootloader/hos/fss.c b/bootloader/hos/fss.c
index 9660f0f..749b161 100644
--- a/bootloader/hos/fss.c
+++ b/bootloader/hos/fss.c
@@ -87,7 +87,7 @@ int parse_fss(launch_ctxt_t *ctxt, const char *value)
 
 	if (fss_meta->magic == FSS0_MAGIC)
 	{
-		gfx_printf(&gfx_con, "Found FSS0, Atmosphere %d.%d.%d-%08x\n"
+		gfx_printf("Found FSS0, Atmosphere %d.%d.%d-%08x\n"
 			"Max HOS supported: %d.%d.%d\n"
 			"Unpacking and loading components..  ",
 			fss_meta->version >> 24, (fss_meta->version >> 16) & 0xFF, (fss_meta->version >> 8) & 0xFF, fss_meta->git_rev,
@@ -131,7 +131,7 @@ int parse_fss(launch_ctxt_t *ctxt, const char *value)
 			f_read(&fp, content, curr_fss_cnt[i].size, NULL);
 		}
 
-		gfx_printf(&gfx_con, "Done!\n");
+		gfx_printf("Done!\n");
 		f_close(&fp);
 
 		return 1;
diff --git a/bootloader/hos/hos.c b/bootloader/hos/hos.c
index f2fcf6a..4d17bec 100644
--- a/bootloader/hos/hos.c
+++ b/bootloader/hos/hos.c
@@ -45,7 +45,7 @@ extern hekate_config h_cfg;
 
 extern void sd_unmount();
 
-//#define DPRINTF(...) gfx_printf(&gfx_con, __VA_ARGS__)
+//#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DPRINTF(...)
 
 #define PKG2_LOAD_ADDR 0xA9800000
@@ -112,17 +112,17 @@ static void _se_lock(bool lock_se)
 	SB(SB_CSR) = 0x10; // Protected IROM enable.
 
 	// This is useful for documenting the bits in the SE config registers, so we can keep it around.
-	/*gfx_printf(&gfx_con, "SE(SE_SECURITY_0) = %08X\n", SE(SE_SECURITY_0));
-	gfx_printf(&gfx_con, "SE(0x4) = %08X\n", SE(0x4));
-	gfx_printf(&gfx_con, "SE(SE_KEY_TABLE_ACCESS_LOCK_OFFSET) = %08X\n", SE(SE_KEY_TABLE_ACCESS_LOCK_OFFSET));
-	gfx_printf(&gfx_con, "SE(SE_RSA_KEYTABLE_ACCESS_LOCK_OFFSET) = %08X\n", SE(SE_RSA_KEYTABLE_ACCESS_LOCK_OFFSET));
+	/*gfx_printf("SE(SE_SECURITY_0) = %08X\n", SE(SE_SECURITY_0));
+	gfx_printf("SE(0x4) = %08X\n", SE(0x4));
+	gfx_printf("SE(SE_KEY_TABLE_ACCESS_LOCK_OFFSET) = %08X\n", SE(SE_KEY_TABLE_ACCESS_LOCK_OFFSET));
+	gfx_printf("SE(SE_RSA_KEYTABLE_ACCESS_LOCK_OFFSET) = %08X\n", SE(SE_RSA_KEYTABLE_ACCESS_LOCK_OFFSET));
 	for(u32 i = 0; i < 16; i++)
-		gfx_printf(&gfx_con, "%02X ", SE(SE_KEY_TABLE_ACCESS_REG_OFFSET + i * 4) & 0xFF);
-	gfx_putc(&gfx_con, '\n');
+		gfx_printf("%02X ", SE(SE_KEY_TABLE_ACCESS_REG_OFFSET + i * 4) & 0xFF);
+	gfx_putc('\n');
 	for(u32 i = 0; i < 2; i++)
-		gfx_printf(&gfx_con, "%02X ", SE(SE_RSA_KEYTABLE_ACCESS_REG_OFFSET + i * 4) & 0xFF);
-	gfx_putc(&gfx_con, '\n');
-	gfx_hexdump(&gfx_con, SE_BASE, (void *)SE_BASE, 0x400);*/
+		gfx_printf("%02X ", SE(SE_RSA_KEYTABLE_ACCESS_REG_OFFSET + i * 4) & 0xFF);
+	gfx_putc('\n');
+	gfx_hexdump(SE_BASE, (void *)SE_BASE, 0x400);*/
 }
 
 void _pmc_scratch_lock(u32 kb)
@@ -308,7 +308,7 @@ static int _read_emmc_pkg1(launch_ctxt_t *ctxt)
 		EPRINTF("Unknown pkg1 version.");
 		goto out;
 	}
-	gfx_printf(&gfx_con, "Identified pkg1 and Keyblob %d\n\n", ctxt->pkg1_id->kb);
+	gfx_printf("Identified pkg1 and Keyblob %d\n\n", ctxt->pkg1_id->kb);
 
 	// Read the correct keyblob.
 	ctxt->keyblob = (u8 *)calloc(NX_EMMC_BLOCKSIZE, 1);
@@ -392,10 +392,10 @@ int hos_launch(ini_sec_t *cfg)
 	ctxt.cfg = cfg;
 
 	if (!gfx_con.mute)
-		gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+		gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
-	gfx_printf(&gfx_con, "Initializing...\n\n");
+	gfx_printf("Initializing...\n\n");
 
 	// Read package1 and the correct keyblob.
 	if (!_read_emmc_pkg1(&ctxt))
@@ -412,7 +412,7 @@ int hos_launch(ini_sec_t *cfg)
 	if (h_cfg.autonogc && !(fuse_read_odm(7) & ~0xF) && ctxt.pkg1_id->kb >= KB_FIRMWARE_VERSION_400)
 		config_kip1patch(&ctxt, "nogc");
 
-	gfx_printf(&gfx_con, "Loaded pkg1 & keyblob\n");
+	gfx_printf("Loaded pkg1 & keyblob\n");
 
 	// Generate keys.
 	if (!h_cfg.se_keygen_done || ctxt.pkg1_id->kb == KB_FIRMWARE_VERSION_620)
@@ -424,7 +424,7 @@ int hos_launch(ini_sec_t *cfg)
 
 		if (ctxt.pkg1_id->kb >= KB_FIRMWARE_VERSION_700 && !h_cfg.sept_run)
 		{
-			gfx_printf(&gfx_con, "Failed to run sept\n");
+			gfx_printf("Failed to run sept\n");
 			return 0;
 		}
 
@@ -444,7 +444,7 @@ int hos_launch(ini_sec_t *cfg)
 		if (ctxt.pkg1_id->kb <= KB_FIRMWARE_VERSION_620)
 		{
 			pkg1_unpack((void *)ctxt.pkg1_id->warmboot_base, (void *)ctxt.pkg1_id->secmon_base, NULL, ctxt.pkg1_id, ctxt.pkg1);
-			gfx_printf(&gfx_con, "Decrypted & unpacked pkg1\n");
+			gfx_printf("Decrypted & unpacked pkg1\n");
 		}
 		else
 		{
@@ -465,7 +465,7 @@ int hos_launch(ini_sec_t *cfg)
 		}
 		// Else we patch it to allow downgrading.
 		patch_t *warmboot_patchset = ctxt.pkg1_id->warmboot_patchset;
-		gfx_printf(&gfx_con, "%kPatching Warmboot%k\n", 0xFFFFBA00, 0xFFCCCCCC);
+		gfx_printf("%kPatching Warmboot%k\n", 0xFFFFBA00, 0xFFCCCCCC);
 		for (u32 i = 0; warmboot_patchset[i].off != 0xFFFFFFFF; i++)
 			*(vu32 *)(ctxt.pkg1_id->warmboot_base + warmboot_patchset[i].off) = warmboot_patchset[i].val;
 	}
@@ -480,32 +480,32 @@ int hos_launch(ini_sec_t *cfg)
 	{
 		// Else we patch it to allow for an unsigned package2 and patched kernel.
 		patch_t *secmon_patchset = ctxt.pkg1_id->secmon_patchset;
-		gfx_printf(&gfx_con, "%kPatching Security Monitor%k\n", 0xFFFFBA00, 0xFFCCCCCC);
+		gfx_printf("%kPatching Security Monitor%k\n", 0xFFFFBA00, 0xFFCCCCCC);
 		for (u32 i = 0; secmon_patchset[i].off != 0xFFFFFFFF; i++)
 			*(vu32 *)(ctxt.pkg1_id->secmon_base + secmon_patchset[i].off) = secmon_patchset[i].val;
 	}
 
-	gfx_printf(&gfx_con, "Loaded warmboot and secmon\n");
+	gfx_printf("Loaded warmboot and secmon\n");
 
 	// Read package2.
 	u8 *bootConfigBuf = _read_emmc_pkg2(&ctxt);
 	if (!bootConfigBuf)
 		return 0;
 
-	gfx_printf(&gfx_con, "Read pkg2\n");
+	gfx_printf("Read pkg2\n");
 
 	// Decrypt package2 and parse KIP1 blobs in INI1 section.
 	pkg2_hdr_t *pkg2_hdr = pkg2_decrypt(ctxt.pkg2);
 	if (!pkg2_hdr)
 	{
-		gfx_printf(&gfx_con, "Pkg2 decryption failed!\n");
+		gfx_printf("Pkg2 decryption failed!\n");
 		return 0;
 	}
 
 	LIST_INIT(kip1_info);
 	pkg2_parse_kips(&kip1_info, pkg2_hdr);
 
-	gfx_printf(&gfx_con, "Parsed ini1\n");
+	gfx_printf("Parsed ini1\n");
 
 	// Use the kernel included in package2 in case we didn't load one already.
 	if (!ctxt.kernel)
@@ -522,7 +522,7 @@ int hos_launch(ini_sec_t *cfg)
 			kernel_patch_t *kernel_patchset = ctxt.pkg2_kernel_id->kernel_patchset;
 			if (kernel_patchset != NULL)
 			{
-				gfx_printf(&gfx_con, "%kPatching kernel%k\n", 0xFFFFBA00, 0xFFCCCCCC);
+				gfx_printf("%kPatching kernel%k\n", 0xFFFFBA00, 0xFFCCCCCC);
 				u32 *temp;
 				for (u32 i = 0; kernel_patchset[i].id != 0xFFFFFFFF; i++)
 				{
@@ -544,7 +544,7 @@ int hos_launch(ini_sec_t *cfg)
 	}
 
 	// Merge extra KIP1s into loaded ones.
-	gfx_printf(&gfx_con, "%kPatching kips%k\n", 0xFFFFBA00, 0xFFCCCCCC);
+	gfx_printf("%kPatching kips%k\n", 0xFFFFBA00, 0xFFCCCCCC);
 	LIST_FOREACH_ENTRY(merge_kip_t, mki, &ctxt.kip1_list, link)
 		pkg2_merge_kip(&kip1_info, (pkg2_kip1_t *)mki->kip1);
 
@@ -562,9 +562,9 @@ int hos_launch(ini_sec_t *cfg)
 	// Rebuild and encrypt package2.
 	pkg2_build_encrypt((void *)PKG2_LOAD_ADDR, ctxt.kernel, ctxt.kernel_size, &kip1_info);
 
-	gfx_printf(&gfx_con, "Rebuilt & loaded pkg2\n");
+	gfx_printf("Rebuilt & loaded pkg2\n");
 
-	gfx_printf(&gfx_con, "\n%kBooting...%k\n", 0xFF96FF00, 0xFFCCCCCC);
+	gfx_printf("\n%kBooting...%k\n", 0xFF96FF00, 0xFFCCCCCC);
 
 	// Clear pkg1/pkg2 keys.
 	se_aes_key_clear(8);
diff --git a/bootloader/hos/hos_config.c b/bootloader/hos/hos_config.c
index f9a7db4..fd5f1fa 100644
--- a/bootloader/hos/hos_config.c
+++ b/bootloader/hos/hos_config.c
@@ -26,7 +26,7 @@
 
 #include "../gfx/gfx.h"
 
-//#define DPRINTF(...) gfx_printf(&gfx_con, __VA_ARGS__)
+//#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DPRINTF(...)
 
 extern void *sd_file_read(const char *path, u32 *fsize);
diff --git a/bootloader/hos/pkg1.c b/bootloader/hos/pkg1.c
index b40b791..eabf9bb 100644
--- a/bootloader/hos/pkg1.c
+++ b/bootloader/hos/pkg1.c
@@ -151,7 +151,7 @@ const pkg1_id_t *pkg1_identify(u8 *pkg1)
 	char build_date[15];
 	memcpy(build_date, (char *)(pkg1 + 0x10), 14);
 	build_date[14] = 0;
-	gfx_printf(&gfx_con, "Found pkg1 ('%s').\n\n", build_date);
+	gfx_printf("Found pkg1 ('%s').\n\n", build_date);
 
 	for (u32 i = 0; _pkg1_ids[i].id; i++)
 		if (!memcmp(pkg1 + 0x10, _pkg1_ids[i].id, 12))
diff --git a/bootloader/hos/pkg2.c b/bootloader/hos/pkg2.c
index 618f221..a348d6f 100644
--- a/bootloader/hos/pkg2.c
+++ b/bootloader/hos/pkg2.c
@@ -27,7 +27,7 @@
 #include "../gfx/gfx.h"
 
 /*#include "util.h"
-#define DPRINTF(...) gfx_printf(&gfx_con, __VA_ARGS__)
+#define DPRINTF(...) gfx_printf(__VA_ARGS__)
 #define DEBUG_PRINTING*/
 #define DPRINTF(...)
 
@@ -680,10 +680,10 @@ int pkg2_decompress_kip(pkg2_kip1_info_t* ki, u32 sectsToDecomp)
 
 		unsigned int compSize = hdr.sections[sectIdx].size_comp;
 		unsigned int outputSize = hdr.sections[sectIdx].size_decomp;
-		gfx_printf(&gfx_con, "Decomping %s KIP1 sect %d of size %d...\n", (const char*)hdr.name, sectIdx, compSize);
+		gfx_printf("Decomping %s KIP1 sect %d of size %d...\n", (const char*)hdr.name, sectIdx, compSize);
 		if (blz_uncompress_srcdest(srcDataPtr, compSize, dstDataPtr, outputSize) == 0)
 		{
-			gfx_printf(&gfx_con, "%kERROR decomping sect %d of %s KIP!%k\n", 0xFFFF0000, sectIdx, (char*)hdr.name, 0xFFCCCCCC);			
+			gfx_printf("%kERROR decomping sect %d of %s KIP!%k\n", 0xFFFF0000, sectIdx, (char*)hdr.name, 0xFFCCCCCC);			
 			free(newKip);
 
 			return 1;
@@ -844,7 +844,7 @@ const char* pkg2_patch_kips(link_t *info, char* patchNames)
 					u32 appliedMask = 1u << currEnabIdx;
 					if (currPatchset->patches == NULL)
 					{
-						gfx_printf(&gfx_con, "Patch '%s' not necessary for %s KIP1\n", currPatchset->name, (const char*)ki->kip1->name);
+						gfx_printf("Patch '%s' not necessary for %s KIP1\n", currPatchset->name, (const char*)ki->kip1->name);
 						patchesApplied |= appliedMask;
 						break;
 					}
@@ -854,7 +854,7 @@ const char* pkg2_patch_kips(link_t *info, char* patchNames)
 					{
 						if (bitsAffected & (1u << currSectIdx))
 						{
-							gfx_printf(&gfx_con, "Applying patch '%s' on %s KIP1 sect %d\n", currPatchset->name, (const char*)ki->kip1->name, currSectIdx);
+							gfx_printf("Applying patch '%s' on %s KIP1 sect %d\n", currPatchset->name, (const char*)ki->kip1->name, currSectIdx);
 							for (const kip1_patch_t* currPatch=currPatchset->patches;currPatch != NULL && currPatch->length != 0; currPatch++)
 							{
 								if (GET_KIP_PATCH_SECTION(currPatch->offset) != currSectIdx)
@@ -863,7 +863,7 @@ const char* pkg2_patch_kips(link_t *info, char* patchNames)
 								u32 currOffset = GET_KIP_PATCH_OFFSET(currPatch->offset);
 								if (memcmp(&kipSectData[currOffset], currPatch->srcData, currPatch->length) != 0)
 								{
-									gfx_printf(&gfx_con, "%kDATA MISMATCH FOR PATCH AT OFFSET 0x%x!!!%k\n", 0xFFFF0000, currOffset, 0xFFCCCCCC);
+									gfx_printf("%kDATA MISMATCH FOR PATCH AT OFFSET 0x%x!!!%k\n", 0xFFFF0000, currOffset, 0xFFCCCCCC);
 									return currPatchset->name; // MUST stop here as kip is likely corrupt.
 								}
 								else
@@ -907,7 +907,7 @@ pkg2_hdr_t *pkg2_decrypt(void *data)
 
 	// Decrypt header.
 	se_aes_crypt_ctr(8, hdr, sizeof(pkg2_hdr_t), hdr, sizeof(pkg2_hdr_t), hdr);
-	//gfx_hexdump(&gfx_con, (u32)hdr, hdr, 0x100);
+	//gfx_hexdump((u32)hdr, hdr, 0x100);
 
 	if (hdr->magic != PKG2_MAGIC)
 		return NULL;
@@ -919,7 +919,7 @@ DPRINTF("sec %d has size %08X\n", i, hdr->sec_size[i]);
 			continue;
 
 		se_aes_crypt_ctr(8, pdata, hdr->sec_size[i], pdata, hdr->sec_size[i], &hdr->sec_ctr[i * 0x10]);
-		//gfx_hexdump(&gfx_con, (u32)pdata, pdata, 0x100);
+		//gfx_hexdump((u32)pdata, pdata, 0x100);
 
 		pdata += hdr->sec_size[i];
 	}
diff --git a/bootloader/ianos/ianos.c b/bootloader/ianos/ianos.c
index 4239219..246a40f 100644
--- a/bootloader/ianos/ianos.c
+++ b/bootloader/ianos/ianos.c
@@ -70,19 +70,19 @@ void ianos_print_error(int errorno)
 	switch (errorno)
 	{
 	case 1:
-		gfx_printf(&gfx_con, "Can't find library!\n");
+		gfx_printf("Can't find library!\n");
 		break;
 	case 2:
-		gfx_printf(&gfx_con, "Cant init ELF context!\n");
+		gfx_printf("Cant init ELF context!\n");
 		break;
 	case 3:
-		gfx_printf(&gfx_con, "Cant alloc memory!\n");
+		gfx_printf("Cant alloc memory!\n");
 		break;
 	case 4:
-		gfx_printf(&gfx_con, "Error loading ELF!\n");
+		gfx_printf("Error loading ELF!\n");
 		break;
 	case 5:
-		gfx_printf(&gfx_con, "Error relocating ELF!\n");
+		gfx_printf("Error relocating ELF!\n");
 		break;
 	}
 }
diff --git a/bootloader/libs/fatfs/ff.c b/bootloader/libs/fatfs/ff.c
index e10dbe5..38d6422 100644
--- a/bootloader/libs/fatfs/ff.c
+++ b/bootloader/libs/fatfs/ff.c
@@ -25,7 +25,7 @@
 #include "diskio.h"		/* Declarations of device I/O functions */
 #include "../../gfx/gfx.h"
 
-#define EFSPRINTF(text, ...) print_error(); gfx_printf(&gfx_con, "%k"text"%k\n", 0xFFFFFF00, 0xFFFFFFFF);
+#define EFSPRINTF(text, ...) print_error(); gfx_printf("%k"text"%k\n", 0xFFFFFF00, 0xFFFFFFFF);
 //#define EFSPRINTF(...)
 
 /*--------------------------------------------------------------------------
@@ -583,7 +583,7 @@ static const BYTE DbcTbl[] = MKCVTBL(TBL_DC, FF_CODE_PAGE);
 
 void print_error()
 {
-	gfx_printf(&gfx_con, "\n\n\n%k[FatFS] Error: %k", 0xFFFFFF00, 0xFFFFFFFF);
+	gfx_printf("\n\n\n%k[FatFS] Error: %k", 0xFFFFFF00, 0xFFFFFFFF);
 }
 
 
diff --git a/bootloader/main.c b/bootloader/main.c
index bf0d349..43254fe 100644
--- a/bootloader/main.c
+++ b/bootloader/main.c
@@ -198,10 +198,10 @@ void check_power_off_from_hos()
 
 		if (h_cfg.autohosoff == 1)
 		{
-			gfx_clear_grey(&gfx_ctxt, 0x1B);
+			gfx_clear_grey(0x1B);
 			u8 *BOOTLOGO = (void *)malloc(0x4000);
 			blz_uncompress_srcdest(BOOTLOGO_BLZ, SZ_BOOTLOGO_BLZ, BOOTLOGO, SZ_BOOTLOGO);
-			gfx_set_rect_grey(&gfx_ctxt, BOOTLOGO, X_BOOTLOGO, Y_BOOTLOGO, 326, 544);
+			gfx_set_rect_grey(BOOTLOGO, X_BOOTLOGO, Y_BOOTLOGO, 326, 544);
 
 			display_backlight_brightness(10, 5000);
 			display_backlight_brightness(100, 25000);
@@ -259,8 +259,8 @@ bool is_ipl_updated(void *buf)
 int launch_payload(char *path, bool update)
 {
 	if (!update)
-		gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+		gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 	if (!path)
 		return 1;
 
@@ -351,8 +351,8 @@ void launch_tools(u8 type)
 
 	ment_t *ments = (ment_t *)malloc(sizeof(ment_t) * (max_entries + 3));
 
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	if (sd_mount())
 	{
@@ -394,7 +394,7 @@ void launch_tools(u8 type)
 					"Choose a file to launch", 0, 0
 			};
 			
-			file_sec = (char *)tui_do_menu(&gfx_con, &menu);
+			file_sec = (char *)tui_do_menu(&menu);
 
 			if (!file_sec)
 			{
@@ -454,8 +454,8 @@ void ini_list_launcher()
 	ini_sec_t *cfg_sec = NULL;
 	LIST_INIT(ini_list_sections);
 
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	if (sd_mount())
 	{
@@ -490,7 +490,7 @@ void ini_list_launcher()
 					ments, "Launch ini configurations", 0, 0
 				};
 
-				cfg_tmp = (ini_sec_t *)tui_do_menu(&gfx_con, &menu);
+				cfg_tmp = (ini_sec_t *)tui_do_menu(&menu);
 
 				if (cfg_tmp)
 				{
@@ -568,8 +568,8 @@ void launch_firmware()
 	ini_sec_t *cfg_sec = NULL;
 	LIST_INIT(ini_sections);
 
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
 	if (sd_mount())
 	{
@@ -618,7 +618,7 @@ void launch_firmware()
 				ments, "Launch configurations", 0, 0
 			};
 
-			cfg_tmp = (ini_sec_t *)tui_do_menu(&gfx_con, &menu);
+			cfg_tmp = (ini_sec_t *)tui_do_menu(&menu);
 
 			if (cfg_tmp)
 			{
@@ -661,8 +661,8 @@ void launch_firmware()
 
 	if (!cfg_sec)
 	{
-		gfx_puts(&gfx_con, "\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n");
-		gfx_printf(&gfx_con, "\nUsing default launch configuration...\n\n\n");
+		gfx_puts("\nPress POWER to Continue.\nPress VOL to go to the menu.\n\n");
+		gfx_printf("\nUsing default launch configuration...\n\n\n");
 
 		u32 btn = btn_wait();
 		if (!(btn & BTN_POWER))
@@ -876,7 +876,7 @@ void auto_launch_firmware()
 					bmpData.pos_y = (1280 - bmpData.size_y) >> 1;
 					// Get background color from 1st pixel.
 					if (bmpData.size_x < 720 || bmpData.size_y < 1280)
-						gfx_clear_color(&gfx_ctxt, *(u32 *)BOOTLOGO);
+						gfx_clear_color(*(u32 *)BOOTLOGO);
 
 					bootlogoFound = true;
 				}
@@ -888,15 +888,15 @@ void auto_launch_firmware()
 		// Render boot logo.
 		if (bootlogoFound)
 		{
-			gfx_render_bmp_argb(&gfx_ctxt, (u32 *)BOOTLOGO, bmpData.size_x, bmpData.size_y,
+			gfx_render_bmp_argb((u32 *)BOOTLOGO, bmpData.size_x, bmpData.size_y,
 				bmpData.pos_x, bmpData.pos_y);
 		}
 		else
 		{
-			gfx_clear_grey(&gfx_ctxt, 0x1B);
+			gfx_clear_grey(0x1B);
 			BOOTLOGO = (void *)malloc(0x4000);
 			blz_uncompress_srcdest(BOOTLOGO_BLZ, SZ_BOOTLOGO_BLZ, BOOTLOGO, SZ_BOOTLOGO);
-			gfx_set_rect_grey(&gfx_ctxt, BOOTLOGO, X_BOOTLOGO, Y_BOOTLOGO, 326, 544);
+			gfx_set_rect_grey(BOOTLOGO, X_BOOTLOGO, Y_BOOTLOGO, 326, 544);
 		}
 		free(BOOTLOGO);
 	}
@@ -988,12 +988,12 @@ void about()
 		"             (/`    ( (`          ) )  '-;   %k[switchbrew]%k\n"
 		"              `      '-;         (-'%k";
 
-	gfx_clear_grey(&gfx_ctxt, 0x1B);
-	gfx_con_setpos(&gfx_con, 0, 0);
+	gfx_clear_grey(0x1B);
+	gfx_con_setpos(0, 0);
 
-	gfx_printf(&gfx_con, credits, 0xFF00CCFF, 0xFFCCCCCC);
+	gfx_printf(credits, 0xFF00CCFF, 0xFFCCCCCC);
 	gfx_con.fntsz = 8;
-	gfx_printf(&gfx_con, octopus, 0xFF00CCFF, 0xFF00FFCC, 0xFF00CCFF, 0xFFCCCCCC);
+	gfx_printf(octopus, 0xFF00CCFF, 0xFF00FFCC, 0xFF00CCFF, 0xFFCCCCCC);
 
 	btn_wait();
 }
@@ -1149,14 +1149,14 @@ void ipl_main()
 	display_init();
 
 	u32 *fb = display_init_framebuffer();
-	gfx_init_ctxt(&gfx_ctxt, fb, 720, 1280, 720);
+	gfx_init_ctxt(fb, 720, 1280, 720);
 
 #ifdef MENU_LOGO_ENABLE
 	Kc_MENU_LOGO = (u8 *)malloc(ALIGN(SZ_MENU_LOGO, 0x1000));
 	blz_uncompress_srcdest(Kc_MENU_LOGO_blz, SZ_MENU_LOGO_BLZ, Kc_MENU_LOGO, SZ_MENU_LOGO);
 #endif
 
-	gfx_con_init(&gfx_con, &gfx_ctxt);
+	gfx_con_init(&gfx_ctxt);
 
 	display_backlight_pwm_init();
 	//display_backlight_brightness(h_cfg.backlight, 1000);
@@ -1165,7 +1165,7 @@ void ipl_main()
 	auto_launch_firmware();
 
 	while (true)
-		tui_do_menu(&gfx_con, &menu_top);
+		tui_do_menu(&menu_top);
 
 	while (true)
 		;
diff --git a/bootloader/sec/tsec.c b/bootloader/sec/tsec.c
index ae83fb9..0c48b93 100644
--- a/bootloader/sec/tsec.c
+++ b/bootloader/sec/tsec.c
@@ -215,16 +215,16 @@ int tsec_query(u8 *tsec_keys, u8 kb, tsec_ctxt_t *tsec_ctxt)
 		smmu_deinit_for_tsec();
 
 		// for (int i = 0; i < kidx; i++)
-		// 	gfx_printf(&gfx_con, "key %08X\n", key[i]);
+		// 	gfx_printf("key %08X\n", key[i]);
 
-		// gfx_printf(&gfx_con, "cpuctl (%08X) mbox (%08X)\n", TSEC(TSEC_CPUCTL), TSEC(TSEC_STATUS));
+		// gfx_printf("cpuctl (%08X) mbox (%08X)\n", TSEC(TSEC_CPUCTL), TSEC(TSEC_STATUS));
 
 		// u32 errst = MC(MC_ERR_STATUS);
-		// gfx_printf(&gfx_con, " MC %08X %08X %08X\n", MC(MC_INTSTATUS), errst, MC(MC_ERR_ADR));
-		// gfx_printf(&gfx_con, " type: %02X\n", errst >> 28);
-		// gfx_printf(&gfx_con, " smmu: %02X\n", (errst >> 25) & 3);
-		// gfx_printf(&gfx_con, " dir:  %s\n", (errst >> 16) & 1 ? "W" : "R");
-		// gfx_printf(&gfx_con, " cid:  %02x\n", errst & 0xFF);
+		// gfx_printf(" MC %08X %08X %08X\n", MC(MC_INTSTATUS), errst, MC(MC_ERR_ADR));
+		// gfx_printf(" type: %02X\n", errst >> 28);
+		// gfx_printf(" smmu: %02X\n", (errst >> 25) & 3);
+		// gfx_printf(" dir:  %s\n", (errst >> 16) & 1 ? "W" : "R");
+		// gfx_printf(" cid:  %02x\n", errst & 0xFF);
 	}
 	else
 	{