diff --git a/stand/lua/core.lua b/stand/lua/core.lua
index 72b19462ae5c..3582720f2a81 100644
--- a/stand/lua/core.lua
+++ b/stand/lua/core.lua
@@ -1,569 +1,578 @@
 --
 -- SPDX-License-Identifier: BSD-2-Clause
 --
 -- Copyright (c) 2015 Pedro Souza <pedrosouza@freebsd.org>
 -- Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
 -- All rights reserved.
 --
 -- Redistribution and use in source and binary forms, with or without
 -- modification, are permitted provided that the following conditions
 -- are met:
 -- 1. Redistributions of source code must retain the above copyright
 --    notice, this list of conditions and the following disclaimer.
 -- 2. Redistributions in binary form must reproduce the above copyright
 --    notice, this list of conditions and the following disclaimer in the
 --    documentation and/or other materials provided with the distribution.
 --
 -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 -- ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 -- SUCH DAMAGE.
 --
 
 local config = require("config")
 local hook = require("hook")
 
 local core = {}
 
 local default_acpi = false
 local default_safe_mode = false
 local default_single_user = false
 local default_verbose = false
 
 local bootenv_list = "bootenvs"
 
 local function composeLoaderCmd(cmd_name, argstr)
 	if argstr ~= nil then
 		cmd_name = cmd_name .. " " .. argstr
 	end
 	return cmd_name
 end
 
 local function recordDefaults()
 	local boot_single = loader.getenv("boot_single") or "no"
 	local boot_verbose = loader.getenv("boot_verbose") or "no"
 
 	default_acpi = core.getACPI()
 	default_single_user = boot_single:lower() ~= "no"
 	default_verbose = boot_verbose:lower() ~= "no"
 
 	core.setACPI(default_acpi)
 	core.setSingleUser(default_single_user)
 	core.setVerbose(default_verbose)
 end
 
 
 -- Globals
 -- try_include will return the loaded module on success, or false and the error
 -- message on failure.
 function try_include(module)
 	if module:sub(1, 1) ~= "/" then
 		local lua_path = loader.lua_path
 		-- XXX Temporary compat shim; this should be removed once the
 		-- loader.lua_path export has sufficiently spread.
 		if lua_path == nil then
 			lua_path = "/boot/lua"
 		end
 		module = lua_path .. "/" .. module
 		-- We only attempt to append an extension if an absolute path
 		-- wasn't specified.  This assumes that the caller either wants
 		-- to treat this like it would require() and specify just the
 		-- base filename, or they know what they're doing as they've
 		-- specified an absolute path and we shouldn't impede.
 		if module:match(".lua$") == nil then
 			module = module .. ".lua"
 		end
 	end
 	if lfs.attributes(module, "mode") ~= "file" then
 		return
 	end
 
 	return dofile(module)
 end
 
 -- Module exports
 -- Commonly appearing constants
 core.KEY_BACKSPACE	= 8
 core.KEY_ENTER		= 13
 core.KEY_DELETE		= 127
 
 -- Note that this is a decimal representation, despite the leading 0 that in
 -- other contexts (outside of Lua) may mean 'octal'
 core.KEYSTR_ESCAPE	= "\027"
 core.KEYSTR_CSI		= core.KEYSTR_ESCAPE .. "["
 core.KEYSTR_RESET	= core.KEYSTR_ESCAPE .. "c"
 
 core.MENU_RETURN	= "return"
 core.MENU_ENTRY		= "entry"
 core.MENU_SEPARATOR	= "separator"
 core.MENU_SUBMENU	= "submenu"
 core.MENU_CAROUSEL_ENTRY	= "carousel_entry"
 
 function core.setVerbose(verbose)
 	if verbose == nil then
 		verbose = not core.verbose
 	end
 
 	if verbose then
 		loader.setenv("boot_verbose", "YES")
 	else
 		loader.unsetenv("boot_verbose")
 	end
 	core.verbose = verbose
 end
 
 function core.setSingleUser(single_user)
 	if single_user == nil then
 		single_user = not core.su
 	end
 
 	if single_user then
 		loader.setenv("boot_single", "YES")
 	else
 		loader.unsetenv("boot_single")
 	end
 	core.su = single_user
 end
 
 function core.hasACPI()
 	-- We can't trust acpi.rsdp to be set if the loader binary doesn't do
 	-- ACPI detection early enough.  UEFI loader historically didn't, so
 	-- we'll fallback to assuming ACPI is enabled if this binary does not
 	-- declare that it probes for ACPI early enough
 	if loader.getenv("acpi.rsdp") ~= nil then
 		return true
 	end
 
 	return not core.hasFeature("EARLY_ACPI")
 end
 
 function core.getACPI()
 	if not core.hasACPI() then
 		return false
 	end
 
 	-- Otherwise, respect disabled if it's set
 	local c = loader.getenv("hint.acpi.0.disabled")
 	return c == nil or tonumber(c) ~= 1
 end
 
 function core.setACPI(acpi)
 	if acpi == nil then
 		acpi = not core.acpi
 	end
 
 	if acpi then
 		config.enableModule("acpi")
 		loader.setenv("hint.acpi.0.disabled", "0")
 	else
 		config.disableModule("acpi")
 		loader.setenv("hint.acpi.0.disabled", "1")
 	end
 	core.acpi = acpi
 end
 
 function core.setSafeMode(safe_mode)
 	if safe_mode == nil then
 		safe_mode = not core.sm
 	end
 	if safe_mode then
 		loader.setenv("kern.smp.disabled", "1")
 		loader.setenv("hw.ata.ata_dma", "0")
 		loader.setenv("hw.ata.atapi_dma", "0")
 		loader.setenv("kern.eventtimer.periodic", "1")
 		loader.setenv("kern.geom.part.check_integrity", "0")
 	else
 		loader.unsetenv("kern.smp.disabled")
 		loader.unsetenv("hw.ata.ata_dma")
 		loader.unsetenv("hw.ata.atapi_dma")
 		loader.unsetenv("kern.eventtimer.periodic")
 		loader.unsetenv("kern.geom.part.check_integrity")
 	end
 	core.sm = safe_mode
 end
 
 function core.clearCachedKernels()
 	-- Clear the kernel cache on config changes, autodetect might have
 	-- changed or if we've switched boot environments then we could have
 	-- a new kernel set.
 	core.cached_kernels = nil
 end
 
 function core.kernelList()
 	if core.cached_kernels ~= nil then
 		return core.cached_kernels
 	end
 
 	local default_kernel = loader.getenv("kernel")
 	local v = loader.getenv("kernels")
 	local autodetect = loader.getenv("kernels_autodetect") or ""
 
 	local kernels = {}
 	local unique = {}
 	local i = 0
 
 	if default_kernel then
 		i = i + 1
 		kernels[i] = default_kernel
 		unique[default_kernel] = true
 	end
 
 	if v ~= nil then
 		for n in v:gmatch("([^;, ]+)[;, ]?") do
 			if unique[n] == nil then
 				i = i + 1
 				kernels[i] = n
 				unique[n] = true
 			end
 		end
 	end
 
 	-- Do not attempt to autodetect if underlying filesystem
 	-- do not support directory listing (e.g. tftp, http)
 	if not lfs.attributes("/boot", "mode") then
 		autodetect = "no"
 		loader.setenv("kernels_autodetect", "NO")
 	end
 
 	-- Base whether we autodetect kernels or not on a loader.conf(5)
 	-- setting, kernels_autodetect. If it's set to 'yes', we'll add
 	-- any kernels we detect based on the criteria described.
 	if autodetect:lower() ~= "yes" then
 		core.cached_kernels = kernels
 		return core.cached_kernels
 	end
 
 	local present = {}
 
 	-- Automatically detect other bootable kernel directories using a
 	-- heuristic.  Any directory in /boot that contains an ordinary file
 	-- named "kernel" is considered eligible.
 	for file, ftype in lfs.dir("/boot") do
 		local fname = "/boot/" .. file
 
 		if file == "." or file == ".." then
 			goto continue
 		end
 
 		if ftype then
 			if ftype ~= lfs.DT_DIR then
 				goto continue
 			end
 		elseif lfs.attributes(fname, "mode") ~= "directory" then
 			goto continue
 		end
 
 		if lfs.attributes(fname .. "/kernel", "mode") ~= "file" then
 			goto continue
 		end
 
 		if unique[file] == nil then
 			i = i + 1
 			kernels[i] = file
 			unique[file] = true
 		end
 
 		present[file] = true
 
 		::continue::
 	end
 
 	-- If we found more than one kernel, prune the "kernel" specified kernel
 	-- off of the list if it wasn't found during traversal.  If we didn't
 	-- actually find any kernels, we just assume that they know what they're
 	-- doing and leave it alone.
 	if default_kernel and not present[default_kernel] and #kernels > 1 then
 		for i = 1, #kernels do
 			if i == #kernels then
 				kernels[i] = nil
 			else
 				kernels[i] = kernels[i + 1]
 			end
 		end
 	end
 
 	core.cached_kernels = kernels
 	return core.cached_kernels
 end
 
 function core.bootenvDefault()
 	return loader.getenv("zfs_be_active")
 end
 
 function core.bootenvList()
 	local bootenv_count = tonumber(loader.getenv(bootenv_list .. "_count"))
 	local bootenvs = {}
 	local curenv
 	local envcount = 0
 	local unique = {}
 
 	if bootenv_count == nil or bootenv_count <= 0 then
 		return bootenvs
 	end
 
 	-- Currently selected bootenv is always first/default
 	-- On the rewinded list the bootenv may not exists
 	if core.isRewinded() then
 		curenv = core.bootenvDefaultRewinded()
 	else
 		curenv = core.bootenvDefault()
 	end
 	if curenv ~= nil then
 		envcount = envcount + 1
 		bootenvs[envcount] = curenv
 		unique[curenv] = true
 	end
 
 	for curenv_idx = 0, bootenv_count - 1 do
 		curenv = loader.getenv(bootenv_list .. "[" .. curenv_idx .. "]")
 		if curenv ~= nil and unique[curenv] == nil then
 			envcount = envcount + 1
 			bootenvs[envcount] = curenv
 			unique[curenv] = true
 		end
 	end
 	return bootenvs
 end
 
 function core.isCheckpointed()
 	return loader.getenv("zpool_checkpoint") ~= nil
 end
 
 function core.bootenvDefaultRewinded()
 	local defname =  "zfs:!" .. string.sub(core.bootenvDefault(), 5)
 	local bootenv_count = tonumber("bootenvs_check_count")
 
 	if bootenv_count == nil or bootenv_count <= 0 then
 		return defname
 	end
 
 	for curenv_idx = 0, bootenv_count - 1 do
 		local curenv = loader.getenv("bootenvs_check[" .. curenv_idx .. "]")
 		if curenv == defname then
 			return defname
 		end
 	end
 
 	return loader.getenv("bootenvs_check[0]")
 end
 
 function core.isRewinded()
 	return bootenv_list == "bootenvs_check"
 end
 
 function core.changeRewindCheckpoint()
 	if core.isRewinded() then
 		bootenv_list = "bootenvs"
 	else
 		bootenv_list = "bootenvs_check"
 	end
 end
 
 function core.loadEntropy()
 	if core.isUEFIBoot() then
 		if (loader.getenv("entropy_efi_seed") or "no"):lower() == "yes" then
 			local seedsize = loader.getenv("entropy_efi_seed_size") or "2048"
 			loader.perform("efi-seed-entropy " .. seedsize)
 		end
 	end
 end
 
 function core.setDefaults()
 	core.setACPI(default_acpi)
 	core.setSafeMode(default_safe_mode)
 	core.setSingleUser(default_single_user)
 	core.setVerbose(default_verbose)
 end
 
 function core.autoboot(argstr)
 	-- loadelf() only if we've not already loaded a kernel
 	if loader.getenv("kernelname") == nil then
 		config.loadelf()
 	end
 	core.loadEntropy()
 	loader.perform(composeLoaderCmd("autoboot", argstr))
 end
 
 function core.boot(argstr)
 	-- loadelf() only if we've not already loaded a kernel
 	if loader.getenv("kernelname") == nil then
 		config.loadelf()
 	end
 	core.loadEntropy()
 	loader.perform(composeLoaderCmd("boot", argstr))
 end
 
 function core.hasFeature(name)
 	if not loader.has_feature then
 		-- Loader too old, no feature support
 		return nil, "No feature support in loaded loader"
 	end
 
 	return loader.has_feature(name)
 end
 
 function core.isSingleUserBoot()
 	local single_user = loader.getenv("boot_single")
 	return single_user ~= nil and single_user:lower() == "yes"
 end
 
 function core.isUEFIBoot()
 	local efiver = loader.getenv("efi-version")
 
 	return efiver ~= nil
 end
 
 function core.isZFSBoot()
 	local c = loader.getenv("currdev")
 
 	if c ~= nil then
 		return c:match("^zfs:") ~= nil
 	end
 	return false
 end
 
 function core.isFramebufferConsole()
 	local c = loader.getenv("console")
 	if c ~= nil then
 		if c:find("efi") == nil and c:find("vidconsole") == nil then
 			return false
 		end
 		if loader.getenv("screen.depth") ~= nil then
 			return true
 		end
 	end
 	return false
 end
 
 function core.isSerialConsole()
 	local c = loader.getenv("console")
 	if c ~= nil then
 		-- serial console is comconsole, but also userboot.
 		-- userboot is there, because we have no way to know
 		-- if the user terminal can draw unicode box chars or not.
 		if c:find("comconsole") ~= nil or c:find("userboot") ~= nil then
 			return true
 		end
 	end
 	return false
 end
 
 function core.isSerialBoot()
 	local s = loader.getenv("boot_serial")
 	if s ~= nil then
 		return true
 	end
 
 	local m = loader.getenv("boot_multicons")
 	if m ~= nil then
 		return true
 	end
 	return false
 end
 
 -- Is the menu skipped in the environment in which we've booted?
 function core.isMenuSkipped()
 	return string.lower(loader.getenv("beastie_disable") or "") == "yes"
 end
 
 -- This may be a better candidate for a 'utility' module.
 function core.deepCopyTable(tbl)
 	local new_tbl = {}
 	for k, v in pairs(tbl) do
 		if type(v) == "table" then
 			new_tbl[k] = core.deepCopyTable(v)
 		else
 			new_tbl[k] = v
 		end
 	end
 	return new_tbl
 end
 
 -- XXX This should go away if we get the table lib into shape for importing.
 -- As of now, it requires some 'os' functions, so we'll implement this in lua
 -- for our uses
 function core.popFrontTable(tbl)
 	-- Shouldn't reasonably happen
 	if #tbl == 0 then
 		return nil, nil
 	elseif #tbl == 1 then
 		return tbl[1], {}
 	end
 
 	local first_value = tbl[1]
 	local new_tbl = {}
 	-- This is not a cheap operation
 	for k, v in ipairs(tbl) do
 		if k > 1 then
 			new_tbl[k - 1] = v
 		end
 	end
 
 	return first_value, new_tbl
 end
 
 function core.getConsoleName()
 	if loader.getenv("boot_multicons") ~= nil then
 		if loader.getenv("boot_serial") ~= nil then
 			return "Dual (Serial primary)"
 		else
 			return "Dual (Video primary)"
 		end
 	else
 		if loader.getenv("boot_serial") ~= nil then
 			return "Serial"
 		else
 			return "Video"
 		end
 	end
 end
 
 function core.nextConsoleChoice()
 	if loader.getenv("boot_multicons") ~= nil then
 		if loader.getenv("boot_serial") ~= nil then
 			loader.unsetenv("boot_serial")
 		else
 			loader.unsetenv("boot_multicons")
 			loader.setenv("boot_serial", "YES")
 		end
 	else
 		if loader.getenv("boot_serial") ~= nil then
 			loader.unsetenv("boot_serial")
 		else
 			loader.setenv("boot_multicons", "YES")
 			loader.setenv("boot_serial", "YES")
 		end
 	end
 end
 
+-- The graphical-enabled loaders have unicode drawing character support. The
+-- text-only ones do not. We check the old and new bindings for term_drawrect as
+-- a proxy for unicode support, which will work on older boot loaders as well
+-- as be future proof for when we remove the old binding. This also abstracts
+-- out the test to one spot in case we start to export this notion more directly.
+function core.hasUnicode()
+	 return gfx.term_drawrect ~= nil or loader.term_drawrect ~= nil
+end
+
 -- Sanity check the boot loader revision
 -- Loaders with version 3.0 have everything that we need without backwards
 -- compatible hacks. Warn users that still have old versions to upgrade so
 -- that we can remove the backwards compatible hacks in the future since
 -- they have been there a long time.
 local loader_major = 3
 
 function core.loaderTooOld()
 	return loader.version == nil or loader.version < loader_major * 1000
 end
 
 if core.loaderTooOld() then
 	print("**********************************************************************")
 	print("**********************************************************************")
 	print("*****                                                            *****")
 	print("*****           BOOT LOADER IS TOO OLD. PLEASE UPGRADE.          *****")
 	print("*****                                                            *****")
 	print("**********************************************************************")
 	print("**********************************************************************")
 end
 
 recordDefaults()
 hook.register("config.reloaded", core.clearCachedKernels)
 return core
diff --git a/stand/lua/drawer.lua b/stand/lua/drawer.lua
index a009b78164df..612bd2f5317f 100644
--- a/stand/lua/drawer.lua
+++ b/stand/lua/drawer.lua
@@ -1,536 +1,558 @@
 --
 -- SPDX-License-Identifier: BSD-2-Clause
 --
 -- Copyright (c) 2015 Pedro Souza <pedrosouza@freebsd.org>
 -- Copyright (c) 2018 Kyle Evans <kevans@FreeBSD.org>
 -- All rights reserved.
 --
 -- Redistribution and use in source and binary forms, with or without
 -- modification, are permitted provided that the following conditions
 -- are met:
 -- 1. Redistributions of source code must retain the above copyright
 --    notice, this list of conditions and the following disclaimer.
 -- 2. Redistributions in binary form must reproduce the above copyright
 --    notice, this list of conditions and the following disclaimer in the
 --    documentation and/or other materials provided with the distribution.
 --
 -- THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 -- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 -- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 -- ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 -- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 -- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 -- OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 -- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 -- LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 -- OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 -- SUCH DAMAGE.
 --
 
 local color = require("color")
 local config = require("config")
 local core = require("core")
 local screen = require("screen")
 
 local drawer = {}
 
 local fbsd_brand
 local none
 
 local menu_name_handlers
 local branddefs
 local logodefs
 local brand_position
 local logo_position
 local menu_position
 local frame_size
 local default_shift
 local shift
 
 -- Make this code compatible with older loader binaries. We moved the term_*
 -- functions from loader to the gfx. if we're running on an older loader that
 -- has these functions, create aliases for them in gfx. The loader binary might
 -- be so old as to not have them, but in that case, we want to copy the nil
 -- values. The new loader will provide loader.* versions of all the gfx.*
 -- functions for backwards compatibility, so we only define the functions we use
 -- here.
 if gfx == nil then
 	gfx = {}
 	gfx.term_drawrect = loader.term_drawrect
 	gfx.term_putimage = loader.term_putimage
 end
 
 local function menuEntryName(drawing_menu, entry)
 	local name_handler = menu_name_handlers[entry.entry_type]
 
 	if name_handler ~= nil then
 		return name_handler(drawing_menu, entry)
 	end
 	if type(entry.name) == "function" then
 		return entry.name()
 	end
 	return entry.name
 end
 
 local function processFile(gfxname)
 	if gfxname == nil then
 		return false, "Missing filename"
 	end
 
 	local ret = try_include('gfx-' .. gfxname)
 	if ret == nil then
 		return false, "Failed to include gfx-" .. gfxname
 	end
 
 	-- Legacy format
 	if type(ret) ~= "table" then
 		return true
 	end
 
 	for gfxtype, def in pairs(ret) do
 		if gfxtype == "brand" then
 			drawer.addBrand(gfxname, def)
 		elseif gfxtype == "logo" then
 			drawer.addLogo(gfxname, def)
 		else
 			return false, "Unknown graphics type '" .. gfxtype ..
 			    "'"
 		end
 	end
 
 	return true
 end
 
 local function getBranddef(brand)
 	if brand == nil then
 		return nil
 	end
 	-- Look it up
 	local branddef = branddefs[brand]
 
 	-- Try to pull it in
 	if branddef == nil then
 		local res, err = processFile(brand)
 		if not res then
 			-- This fallback should go away after FreeBSD 13.
 			try_include('brand-' .. brand)
 			-- If the fallback also failed, print whatever error
 			-- we encountered in the original processing.
 			if branddefs[brand] == nil then
 				print(err)
 				return nil
 			end
 		end
 
 		branddef = branddefs[brand]
 	end
 
 	return branddef
 end
 
 local function getLogodef(logo)
 	if logo == nil then
 		return nil
 	end
 	-- Look it up
 	local logodef = logodefs[logo]
 
 	-- Try to pull it in
 	if logodef == nil then
 		local res, err = processFile(logo)
 		if not res then
 			-- This fallback should go away after FreeBSD 13.
 			try_include('logo-' .. logo)
 			-- If the fallback also failed, print whatever error
 			-- we encountered in the original processing.
 			if logodefs[logo] == nil then
 				print(err)
 				return nil
 			end
 		end
 
 		logodef = logodefs[logo]
 	end
 
 	return logodef
 end
 
 local function draw(x, y, logo)
 	for i = 1, #logo do
 		screen.setcursor(x, y + i - 1)
 		printc(logo[i])
 	end
 end
 
 local function drawmenu(menudef)
 	local x = menu_position.x
 	local y = menu_position.y
 
 	x = x + shift.x
 	y = y + shift.y
 
 	-- print the menu and build the alias table
 	local alias_table = {}
 	local entry_num = 0
 	local menu_entries = menudef.entries
 	local effective_line_num = 0
 	if type(menu_entries) == "function" then
 		menu_entries = menu_entries()
 	end
 	for _, e in ipairs(menu_entries) do
 		-- Allow menu items to be conditionally visible by specifying
 		-- a visible function.
 		if e.visible ~= nil and not e.visible() then
 			goto continue
 		end
 		effective_line_num = effective_line_num + 1
 		if e.entry_type ~= core.MENU_SEPARATOR then
 			entry_num = entry_num + 1
 			screen.setcursor(x, y + effective_line_num)
 
 			printc(entry_num .. ". " .. menuEntryName(menudef, e))
 
 			-- fill the alias table
 			alias_table[tostring(entry_num)] = e
 			if e.alias ~= nil then
 				for _, a in ipairs(e.alias) do
 					alias_table[a] = e
 				end
 			end
 		else
 			screen.setcursor(x, y + effective_line_num)
 			printc(menuEntryName(menudef, e))
 		end
 		::continue::
 	end
 	return alias_table
 end
 
 local function defaultframe()
 	if core.isSerialConsole() then
 		return "ascii"
 	end
 	return "double"
 end
 
 local function drawframe()
 	local x = menu_position.x - 3
 	local y = menu_position.y - 1
 	local w = frame_size.w
 	local h = frame_size.h
 
 	local framestyle = loader.getenv("loader_menu_frame") or defaultframe()
 	local framespec = drawer.frame_styles[framestyle]
 	-- If we don't have a framespec for the current frame style, just don't
 	-- draw a box.
 	if framespec == nil then
 		return false
 	end
 
 	local hl = framespec.horizontal
 	local vl = framespec.vertical
 
 	local tl = framespec.top_left
 	local bl = framespec.bottom_left
 	local tr = framespec.top_right
 	local br = framespec.bottom_right
 
 	x = x + shift.x
 	y = y + shift.y
 
 	if core.isFramebufferConsole() and gfx.term_drawrect ~= nil then
 		gfx.term_drawrect(x, y, x + w, y + h)
 		return true
 	end
 
 	screen.setcursor(x, y); printc(tl)
 	screen.setcursor(x, y + h); printc(bl)
 	screen.setcursor(x + w, y); printc(tr)
 	screen.setcursor(x + w, y + h); printc(br)
 
 	screen.setcursor(x + 1, y)
 	for _ = 1, w - 1 do
 		printc(hl)
 	end
 
 	screen.setcursor(x + 1, y + h)
 	for _ = 1, w - 1 do
 		printc(hl)
 	end
 
 	for i = 1, h - 1 do
 		screen.setcursor(x, y + i)
 		printc(vl)
 		screen.setcursor(x + w, y + i)
 		printc(vl)
 	end
 	return true
 end
 
 local function drawbox()
 	local x = menu_position.x - 3
 	local y = menu_position.y - 1
 	local w = frame_size.w
 	local menu_header = loader.getenv("loader_menu_title") or
 	    "Welcome to FreeBSD"
 	local menu_header_align = loader.getenv("loader_menu_title_align")
 	local menu_header_x
 
 	x = x + shift.x
 	y = y + shift.y
 
 	if drawframe(x, y, w) == false then
 		return
 	end
 
 	if menu_header_align ~= nil then
 		menu_header_align = menu_header_align:lower()
 		if menu_header_align == "left" then
 			-- Just inside the left border on top
 			menu_header_x = x + 1
 		elseif menu_header_align == "right" then
 			-- Just inside the right border on top
 			menu_header_x = x + w - #menu_header
 		end
 	end
 	if menu_header_x == nil then
 		menu_header_x = x + (w // 2) - (#menu_header // 2)
 	end
 	screen.setcursor(menu_header_x - 1, y)
 	if menu_header ~= "" then
 		printc(" " .. menu_header .. " ")
 	end
 
 end
 
 local function drawbrand()
 	local x = tonumber(loader.getenv("loader_brand_x")) or
 	    brand_position.x
 	local y = tonumber(loader.getenv("loader_brand_y")) or
 	    brand_position.y
 
 	local branddef = getBranddef(loader.getenv("loader_brand"))
 
 	if branddef == nil then
 		branddef = getBranddef(drawer.default_brand)
 	end
 
 	local graphic = branddef.graphic
 
 	x = x + shift.x
 	y = y + shift.y
 	if branddef.shift ~= nil then
 		x = x +	branddef.shift.x
 		y = y + branddef.shift.y
 	end
 
 	if core.isFramebufferConsole() and
 	    gfx.term_putimage ~= nil and
 	    branddef.image ~= nil then
 		if gfx.term_putimage(branddef.image, 1, 1, 0, 7, 0)
 		then
 			return true
 		end
 	end
 	draw(x, y, graphic)
 end
 
 local function drawlogo()
 	local x = tonumber(loader.getenv("loader_logo_x")) or
 	    logo_position.x
 	local y = tonumber(loader.getenv("loader_logo_y")) or
 	    logo_position.y
 
 	local logo = loader.getenv("loader_logo")
 	local colored = color.isEnabled()
 
 	local logodef = getLogodef(logo)
 
 	if logodef == nil or logodef.graphic == nil or
 	    (not colored and logodef.requires_color) then
 		-- Choose a sensible default
 		if colored then
 			logodef = getLogodef(drawer.default_color_logodef)
 		else
 			logodef = getLogodef(drawer.default_bw_logodef)
 		end
 
 		-- Something has gone terribly wrong.
 		if logodef == nil then
 			logodef = getLogodef(drawer.default_fallback_logodef)
 		end
 	end
 
 	if logodef ~= nil and logodef.graphic == none then
 		shift = logodef.shift
 	else
 		shift = default_shift
 	end
 
 	x = x + shift.x
 	y = y + shift.y
 
 	if logodef ~= nil and logodef.shift ~= nil then
 		x = x + logodef.shift.x
 		y = y + logodef.shift.y
 	end
 
 	if core.isFramebufferConsole() and
 	    gfx.term_putimage ~= nil and
 	    logodef.image ~= nil then
 		local y1 = 15
 
 		if logodef.image_rl ~= nil then
 			y1 = logodef.image_rl
 		end
 		if gfx.term_putimage(logodef.image, x, y, 0, y + y1, 0)
 		then
 			return true
 		end
 	end
 	draw(x, y, logodef.graphic)
 end
 
 local function drawitem(func)
 	local console = loader.getenv("console")
 
 	for c in string.gmatch(console, "%w+") do
 		loader.setenv("console", c)
 		func()
 	end
 	loader.setenv("console", console)
 end
 
 fbsd_brand = {
 "  ______               ____   _____ _____  ",
 " |  ____|             |  _ \\ / ____|  __ \\ ",
 " | |___ _ __ ___  ___ | |_) | (___ | |  | |",
 " |  ___| '__/ _ \\/ _ \\|  _ < \\___ \\| |  | |",
 " | |   | | |  __/  __/| |_) |____) | |__| |",
 " | |   | | |    |    ||     |      |      |",
 " |_|   |_|  \\___|\\___||____/|_____/|_____/ "
 }
 none = {""}
 
 menu_name_handlers = {
 	-- Menu name handlers should take the menu being drawn and entry being
 	-- drawn as parameters, and return the name of the item.
 	-- This is designed so that everything, including menu separators, may
 	-- have their names derived differently. The default action for entry
 	-- types not specified here is to use entry.name directly.
 	[core.MENU_SEPARATOR] = function(_, entry)
 		if entry.name ~= nil then
 			if type(entry.name) == "function" then
 				return entry.name()
 			end
 			return entry.name
 		end
 		return ""
 	end,
 	[core.MENU_CAROUSEL_ENTRY] = function(_, entry)
 		local carid = entry.carousel_id
 		local caridx = config.getCarouselIndex(carid)
 		local choices = entry.items
 		if type(choices) == "function" then
 			choices = choices()
 		end
 		if #choices < caridx then
 			caridx = 1
 		end
 		return entry.name(caridx, choices[caridx], choices)
 	end,
 }
 
 branddefs = {
 	-- Indexed by valid values for loader_brand in loader.conf(5). Valid
 	-- keys are: graphic (table depicting graphic)
 	["fbsd"] = {
 		graphic = fbsd_brand,
 		image = "/boot/images/freebsd-brand-rev.png",
 	},
 	["none"] = {
 		graphic = none,
 	},
 }
 
 logodefs = {
 	-- Indexed by valid values for loader_logo in loader.conf(5). Valid keys
 	-- are: requires_color (boolean), graphic (table depicting graphic), and
 	-- shift (table containing x and y).
 	["tribute"] = {
 		graphic = fbsd_brand,
 	},
 	["tributebw"] = {
 		graphic = fbsd_brand,
 	},
 	["none"] = {
 		graphic = none,
 		shift = {x = 17, y = 0},
 	},
 }
 
 brand_position = {x = 2, y = 1}
 logo_position = {x = 46, y = 4}
 menu_position = {x = 5, y = 10}
 frame_size = {w = 42, h = 13}
 default_shift = {x = 0, y = 0}
 shift = default_shift
 
 -- Module exports
 drawer.default_brand = 'fbsd'
 drawer.default_color_logodef = 'orb'
 drawer.default_bw_logodef = 'orbbw'
 -- For when things go terribly wrong; this def should be present here in the
 -- drawer module in case it's a filesystem issue.
 drawer.default_fallback_logodef = 'none'
 
 -- These should go away after FreeBSD 13; only available for backwards
 -- compatibility with old logo- files.
 function drawer.addBrand(name, def)
 	branddefs[name] = def
 end
 
 function drawer.addLogo(name, def)
 	logodefs[name] = def
 end
 
 drawer.frame_styles = {
 	-- Indexed by valid values for loader_menu_frame in loader.conf(5).
 	-- All of the keys appearing below must be set for any menu frame style
 	-- added to drawer.frame_styles.
 	["ascii"] = {
 		horizontal	= "-",
 		vertical	= "|",
 		top_left	= "+",
 		bottom_left	= "+",
 		top_right	= "+",
 		bottom_right	= "+",
 	},
-	["single"] = {
+}
+
+if core.hasUnicode() then
+	-- unicode based framing characters
+	drawer.frame_styles["single"] = {
 		horizontal	= "\xE2\x94\x80",
 		vertical	= "\xE2\x94\x82",
 		top_left	= "\xE2\x94\x8C",
 		bottom_left	= "\xE2\x94\x94",
 		top_right	= "\xE2\x94\x90",
 		bottom_right	= "\xE2\x94\x98",
-	},
-	["double"] = {
+	}
+	drawer.frame_styles["double"] = {
 		horizontal	= "\xE2\x95\x90",
 		vertical	= "\xE2\x95\x91",
 		top_left	= "\xE2\x95\x94",
 		bottom_left	= "\xE2\x95\x9A",
 		top_right	= "\xE2\x95\x97",
 		bottom_right	= "\xE2\x95\x9D",
-	},
-}
+	}
+else
+	-- non-unicode cons25-style framing characters
+	drawer.frame_styles["single"] = {
+		horizontal	= "\xC4",
+		vertical	= "\xB3",
+		top_left	= "\xDA",
+		bottom_left	= "\xC0",
+		top_right	= "\xBF",
+		bottom_right	= "\xD9",
+        }
+	drawer.frame_styles["double"] = {
+		horizontal	= "\xCD",
+		vertical	= "\xBA",
+		top_left	= "\xC9",
+		bottom_left	= "\xC8",
+		top_right	= "\xBB",
+		bottom_right	= "\xBC",
+	}
+end
 
 function drawer.drawscreen(menudef)
 	-- drawlogo() must go first.
 	-- it determines the positions of other elements
 	drawitem(drawlogo)
 	drawitem(drawbrand)
 	drawitem(drawbox)
 	return drawmenu(menudef)
 end
 
 return drawer