Add more files for labels

Try to fix path
Add name to install
2025-12-21 19:55:00 +00:00 · 2021-02-14 14:59:59 +01:00 · 2021-02-14 14:39:48 +01:00 · 2021-02-14 14:10:04 +01:00 · 2021-02-14 13:51:04 +01:00 · 2021-02-14 13:48:51 +01:00
72 changed files with 3331 additions and 7250 deletions
--- a/.copr/Makefile
+++ b/.copr/Makefile
@@ -0,0 +1,4 @@
 srpm:
 	cd $(spec)
 	make github
 	rpmbuild -vv -bs ly.spec --define "_srcrpmdir $(outdir)"
--- a/.gitea
+++ b/.gitea
@@ -0,0 +1,15 @@
 [submodule "sub/argoat"]
 	path = sub/argoat
 	url = https://git.nullgemm.fr/nullgemm/argoat.git
 [submodule "sub/configator"]
 	path = sub/configator
 	url = https://git.nullgemm.fr/nullgemm/configator.git
 [submodule "sub/ctypes"]
 	path = sub/ctypes
 	url = https://git.nullgemm.fr/nullgemm/ctypes.git
 [submodule "sub/dragonfail"]
 	path = sub/dragonfail
 	url = https://git.nullgemm.fr/nullgemm/dragonfail.git
 [submodule "sub/termbox_next"]
 	path = sub/termbox_next
 	url = https://git.nullgemm.fr/nullgemm/termbox_next.git
--- a/.github
+++ b/.github
@@ -0,0 +1,15 @@
 [submodule "sub/argoat"]
 	path = sub/argoat
 	url = https://github.com/nullgemm/argoat.git
 [submodule "sub/configator"]
 	path = sub/configator
 	url = https://github.com/nullgemm/configator.git
 [submodule "sub/ctypes"]
 	path = sub/ctypes
 	url = https://github.com/nullgemm/ctypes.git
 [submodule "sub/dragonfail"]
 	path = sub/dragonfail
 	url = https://github.com/nullgemm/dragonfail.git
 [submodule "sub/termbox_next"]
 	path = sub/termbox_next
 	url = https://github.com/nullgemm/termbox_next.git
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,4 @@
-.idea/
+bin
-zig-cache/
+obj
-zig-out/
+.gitmodules
 valgrind.log
 .zig-cache
--- a/build.zig
+++ b/build.zig
@@ -1,318 +0,0 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const min_zig_string = "0.12.0";
 const current_zig = builtin.zig_version;
 // Implementing zig version detection through compile time
 comptime {
    const min_zig = std.SemanticVersion.parse(min_zig_string) catch unreachable;
    if (current_zig.order(min_zig) == .lt) {
        @compileError(std.fmt.comptimePrint("Your Zig version v{} does not meet the minimum build requirement of v{}", .{ current_zig, min_zig }));
    }
 }
 const ly_version = std.SemanticVersion{ .major = 1, .minor = 0, .patch = 3 };
 var dest_directory: []const u8 = undefined;
 var data_directory: []const u8 = undefined;
 var exe_name: []const u8 = undefined;
 const ProgressNode = if (current_zig.minor == 12) *std.Progress.Node else std.Progress.Node;
 pub fn build(b: *std.Build) !void {
    dest_directory = b.option([]const u8, "dest_directory", "Specify a destination directory for installation") orelse "";
    data_directory = b.option([]const u8, "data_directory", "Specify a default data directory (default is /etc/ly). This path gets embedded into the binary") orelse "/etc/ly";
    exe_name = b.option([]const u8, "name", "Specify installed executable file name (default is ly)") orelse "ly";
    const bin_directory = try b.allocator.dupe(u8, data_directory);
    data_directory = try std.fs.path.join(b.allocator, &[_][]const u8{ dest_directory, data_directory });
    const build_options = b.addOptions();
    build_options.addOption([]const u8, "data_directory", bin_directory);
    const version_str = try getVersionStr(b, "ly", ly_version);
    build_options.addOption([]const u8, "version", version_str);
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const exe = b.addExecutable(.{
        .name = "ly",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });
    const zigini = b.dependency("zigini", .{ .target = target, .optimize = optimize });
    exe.root_module.addImport("zigini", zigini.module("zigini"));
    exe.root_module.addOptions("build_options", build_options);
    const clap = b.dependency("clap", .{ .target = target, .optimize = optimize });
    exe.root_module.addImport("clap", clap.module("clap"));
    exe.addIncludePath(b.path("include"));
    exe.linkSystemLibrary("pam");
    exe.linkSystemLibrary("xcb");
    exe.linkLibC();
    // HACK: Only fails with ReleaseSafe, so we'll override it.
    const translate_c = b.addTranslateC(.{
        .root_source_file = b.path("include/termbox2.h"),
        .target = target,
        .optimize = if (optimize == .ReleaseSafe) .ReleaseFast else optimize,
    });
    translate_c.defineCMacroRaw("TB_IMPL");
    const termbox2 = translate_c.addModule("termbox2");
    exe.root_module.addImport("termbox2", termbox2);
    if (optimize == .ReleaseSafe) {
        std.debug.print("warn: termbox2 module is being built in ReleaseFast due to a bug.\n", .{});
    }
    b.installArtifact(exe);
    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());
    if (b.args) |args| run_cmd.addArgs(args);
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);
    const installexe_step = b.step("installexe", "Install Ly");
    installexe_step.makeFn = ExeInstaller(true).make;
    installexe_step.dependOn(b.getInstallStep());
    const installnoconf_step = b.step("installnoconf", "Install Ly without its configuration file");
    installnoconf_step.makeFn = ExeInstaller(false).make;
    installnoconf_step.dependOn(b.getInstallStep());
    const installsystemd_step = b.step("installsystemd", "Install the Ly systemd service");
    installsystemd_step.makeFn = ServiceInstaller(.Systemd).make;
    installsystemd_step.dependOn(installexe_step);
    const installopenrc_step = b.step("installopenrc", "Install the Ly openrc service");
    installopenrc_step.makeFn = ServiceInstaller(.Openrc).make;
    installopenrc_step.dependOn(installexe_step);
    const installrunit_step = b.step("installrunit", "Install the Ly runit service");
    installrunit_step.makeFn = ServiceInstaller(.Runit).make;
    installrunit_step.dependOn(installexe_step);
    const uninstallall_step = b.step("uninstallall", "Uninstall Ly and all services");
    uninstallall_step.makeFn = uninstallall;
 }
 pub fn ExeInstaller(install_conf: bool) type {
    return struct {
        pub fn make(step: *std.Build.Step, progress: ProgressNode) !void {
            _ = progress;
            try install_ly(step.owner.allocator, install_conf);
        }
    };
 }
 const InitSystem = enum {
    Systemd,
    Openrc,
    Runit,
 };
 pub fn ServiceInstaller(comptime init_system: InitSystem) type {
    return struct {
        pub fn make(step: *std.Build.Step, progress: ProgressNode) !void {
            _ = progress;
            const allocator = step.owner.allocator;
            switch (init_system) {
                .Openrc => {
                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/init.d" });
                    std.fs.cwd().makePath(service_path) catch {};
                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
                    defer service_dir.close();
                    try std.fs.cwd().copyFile("res/ly-openrc", service_dir, exe_name, .{ .override_mode = 0o755 });
                },
                .Runit => {
                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/sv/ly" });
                    std.fs.cwd().makePath(service_path) catch {};
                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
                    defer service_dir.close();
                    const supervise_path = try std.fs.path.join(allocator, &[_][]const u8{ service_path, "supervise" });
                    try std.fs.cwd().copyFile("res/ly-runit-service/conf", service_dir, "conf", .{});
                    try std.fs.cwd().copyFile("res/ly-runit-service/finish", service_dir, "finish", .{ .override_mode = 0o755 });
                    try std.fs.cwd().copyFile("res/ly-runit-service/run", service_dir, "run", .{ .override_mode = 0o755 });
                    try std.fs.cwd().symLink("/run/runit/supervise.ly", supervise_path, .{});
                },
                .Systemd => {
                    const service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/usr/lib/systemd/system" });
                    std.fs.cwd().makePath(service_path) catch {};
                    var service_dir = std.fs.cwd().openDir(service_path, .{}) catch unreachable;
                    defer service_dir.close();
                    try std.fs.cwd().copyFile("res/ly.service", service_dir, "ly.service", .{ .override_mode = 0o644 });
                },
            }
        }
    };
 }
 fn install_ly(allocator: std.mem.Allocator, install_config: bool) !void {
    std.fs.cwd().makePath(data_directory) catch {
        std.debug.print("warn: {s} already exists as a directory.\n", .{data_directory});
    };
    const lang_path = try std.fs.path.join(allocator, &[_][]const u8{ data_directory, "/lang" });
    std.fs.cwd().makePath(lang_path) catch {
        std.debug.print("warn: {s} already exists as a directory.\n", .{data_directory});
    };
    var current_dir = std.fs.cwd();
    {
        const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/usr/bin" });
        std.fs.cwd().makePath(exe_path) catch {
            if (!std.mem.eql(u8, dest_directory, "")) {
                std.debug.print("warn: {s} already exists as a directory.\n", .{exe_path});
            }
        };
        var executable_dir = std.fs.cwd().openDir(exe_path, .{}) catch unreachable;
        defer executable_dir.close();
        try current_dir.copyFile("zig-out/bin/ly", executable_dir, exe_name, .{});
    }
    {
        var config_dir = std.fs.cwd().openDir(data_directory, .{}) catch unreachable;
        defer config_dir.close();
        if (install_config) {
            try current_dir.copyFile("res/config.ini", config_dir, "config.ini", .{});
        }
        try current_dir.copyFile("res/xsetup.sh", config_dir, "xsetup.sh", .{});
        try current_dir.copyFile("res/wsetup.sh", config_dir, "wsetup.sh", .{});
    }
    {
        var lang_dir = std.fs.cwd().openDir(lang_path, .{}) catch unreachable;
        defer lang_dir.close();
        try current_dir.copyFile("res/lang/cat.ini", lang_dir, "cat.ini", .{});
        try current_dir.copyFile("res/lang/cs.ini", lang_dir, "cs.ini", .{});
        try current_dir.copyFile("res/lang/de.ini", lang_dir, "de.ini", .{});
        try current_dir.copyFile("res/lang/en.ini", lang_dir, "en.ini", .{});
        try current_dir.copyFile("res/lang/es.ini", lang_dir, "es.ini", .{});
        try current_dir.copyFile("res/lang/fr.ini", lang_dir, "fr.ini", .{});
        try current_dir.copyFile("res/lang/it.ini", lang_dir, "it.ini", .{});
        try current_dir.copyFile("res/lang/pl.ini", lang_dir, "pl.ini", .{});
        try current_dir.copyFile("res/lang/pt.ini", lang_dir, "pt.ini", .{});
        try current_dir.copyFile("res/lang/pt_BR.ini", lang_dir, "pt_BR.ini", .{});
        try current_dir.copyFile("res/lang/ro.ini", lang_dir, "ro.ini", .{});
        try current_dir.copyFile("res/lang/ru.ini", lang_dir, "ru.ini", .{});
        try current_dir.copyFile("res/lang/sr.ini", lang_dir, "sr.ini", .{});
        try current_dir.copyFile("res/lang/sv.ini", lang_dir, "sv.ini", .{});
        try current_dir.copyFile("res/lang/tr.ini", lang_dir, "tr.ini", .{});
        try current_dir.copyFile("res/lang/uk.ini", lang_dir, "uk.ini", .{});
    }
    {
        const pam_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/pam.d" });
        std.fs.cwd().makePath(pam_path) catch {
            if (!std.mem.eql(u8, dest_directory, "")) {
                std.debug.print("warn: {s} already exists as a directory.\n", .{pam_path});
            }
        };
        var pam_dir = std.fs.cwd().openDir(pam_path, .{}) catch unreachable;
        defer pam_dir.close();
        try current_dir.copyFile("res/pam.d/ly", pam_dir, "ly", .{ .override_mode = 0o644 });
    }
 }
 pub fn uninstallall(step: *std.Build.Step, progress: ProgressNode) !void {
    _ = progress;
    try std.fs.cwd().deleteTree(data_directory);
    const allocator = step.owner.allocator;
    const exe_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/usr/bin/", exe_name });
    try std.fs.cwd().deleteFile(exe_path);
    const pam_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/pam.d/ly" });
    try std.fs.cwd().deleteFile(pam_path);
    const systemd_service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/usr/lib/systemd/system/ly.service" });
    std.fs.cwd().deleteFile(systemd_service_path) catch {
        std.debug.print("warn: systemd service not found.\n", .{});
    };
    const openrc_service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/init.d/ly" });
    std.fs.cwd().deleteFile(openrc_service_path) catch {
        std.debug.print("warn: openrc service not found.\n", .{});
    };
    const runit_service_path = try std.fs.path.join(allocator, &[_][]const u8{ dest_directory, "/etc/sv/ly" });
    std.fs.cwd().deleteTree(runit_service_path) catch {
        std.debug.print("warn: runit service not found.\n", .{});
    };
 }
 fn getVersionStr(b: *std.Build, name: []const u8, version: std.SemanticVersion) ![]const u8 {
    const version_str = b.fmt("{d}.{d}.{d}", .{ version.major, version.minor, version.patch });
    var status: u8 = undefined;
    const git_describe_raw = b.runAllowFail(&[_][]const u8{
        "git",
        "-C",
        b.build_root.path orelse ".",
        "describe",
        "--match",
        "*.*.*",
        "--tags",
    }, &status, .Ignore) catch {
        return version_str;
    };
    var git_describe = std.mem.trim(u8, git_describe_raw, " \n\r");
    git_describe = std.mem.trimLeft(u8, git_describe, "v");
    switch (std.mem.count(u8, git_describe, "-")) {
        0 => {
            if (!std.mem.eql(u8, version_str, git_describe)) {
                std.debug.print("{s} version '{s}' does not match git tag: '{s}'\n", .{ name, version_str, git_describe });
                std.process.exit(1);
            }
            return version_str;
        },
        2 => {
            // Untagged development build (e.g. 0.10.0-dev.2025+ecf0050a9).
            var it = std.mem.splitScalar(u8, git_describe, '-');
            const tagged_ancestor = std.mem.trimLeft(u8, it.first(), "v");
            const commit_height = it.next().?;
            const commit_id = it.next().?;
            const ancestor_ver = try std.SemanticVersion.parse(tagged_ancestor);
            if (version.order(ancestor_ver) != .gt) {
                std.debug.print("{s} version '{}' must be greater than tagged ancestor '{}'\n", .{ name, version, ancestor_ver });
                std.process.exit(1);
            }
            // Check that the commit hash is prefixed with a 'g' (a Git convention).
            if (commit_id.len < 1 or commit_id[0] != 'g') {
                std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
                return version_str;
            }
            // The version is reformatted in accordance with the https://semver.org specification.
            return b.fmt("{s}-dev.{s}+{s}", .{ version_str, commit_height, commit_id[1..] });
        },
        else => {
            std.debug.print("Unexpected `git describe` output: {s}\n", .{git_describe});
            return version_str;
        },
    }
 }
--- a/build.zig.zon
+++ b/build.zig.zon
@@ -1,16 +0,0 @@
 .{
    .name = "ly",
    .version = "1.0.0",
    .minimum_zig_version = "0.12.0",
    .dependencies = .{
        .clap = .{
            .url = "https://github.com/Hejsil/zig-clap/archive/refs/tags/0.9.1.tar.gz",
            .hash = "122062d301a203d003547b414237229b09a7980095061697349f8bef41be9c30266b",
        },
        .zigini = .{
            .url = "https://github.com/Kawaii-Ash/zigini/archive/0bba97a12582928e097f4074cc746c43351ba4c8.tar.gz",
            .hash = "12209b971367b4066d40ecad4728e6fdffc4cc4f19356d424c2de57f5b69ac7a619a",
        },
    },
    .paths = .{""},
 }
--- a/changelog.md
+++ b/changelog.md
@@ -1,52 +0,0 @@
 # Zig Rewrite (Version 1.0.0)
 ## Config Options
 res/config.ini contains all of the available config options and their default values.
 ### Additions
 + `border_fg` has been introduced to change the color of the borders.
 + `term_restore_cursor_cmd` should restore the cursor to it's usual state.
 + `vi_mode` to enable vi keybindings.
 + `sleep_key` and `sleep_cmd`.
 + `numlock` to set numlock on startup.
 + `initial_info_text` allows changing the initial text on the info line.
 + `box_title` to display a title at the top of the main box
 Note: `sleep_cmd` is unset by default, meaning it's hidden and has no effect. 
 ### Changes
 + xinitrc can be set to null to hide it.
 + `blank_password` has been renamed to `clear_password`.
 + `save_file` has been deprecated and will be removed in a future version.
 ### Removals
 + `wayland_specifier` has been removed.
 ## Save File
 The save file is now in .ini format and stored in the same directory as the config.
 Older save files will be migrated to the new format.
 Example:
 ```ini
 user = ash
 session_index = 0
 ```
 ## Misc
 + Display server name added next to selected session.
 + getty@tty2 has been added as a conflict in res/ly.service, so if it is running, ly should still be able to start.
 + `XDG_CURRENT_DESKTOP` is now set by ly.
 + LANG is no longer set by ly.
 + X Server PID is fetched from /tmp/X{d}.lock to be able to kill the process since it detaches.
 + Non .desktop files are now ignored in sessions directory.
 + PAM auth is now done in a child process. (Fixes some issues with logging out and back in).
 + When ly receives SIGTERM, the terminal is now cleared and existing child processes are cleaned up.
 + Shift+Tab now focuses previous input.
 + Display text in the info line when authenticating.
--- a/include/termbox2.h
+++ b/include/termbox2.h
--- a/ly.spec.rpkg
+++ b/ly.spec.rpkg
@@ -0,0 +1,78 @@
 %define relabel_files() \
 restorecon -R /usr/bin/ly; \
 %define selinux_policyver 3.14.6-34
 Name:           {{{ git_dir_name }}}
 Version:        {{{ git_dir_version }}}
 Release:        1%{?dist}
 Summary:        A TUI display manager
 License:        WTFPL
 URL:            https://github.com/nullgemm/ly
 VCS:            {{{ git_dir_vcs }}}
 Source:         {{{ git_dir_pack }}}
 BuildRequires:  libxcb-devel
 BuildRequires:  pam-devel
 BuildRequires:  make
 BuildRequires:  git
 BuildRequires:  gcc
 BuildRequires:  selinux-policy-devel
 Requires:       libxcb
 Requires:       pam
 %description
 Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD.
 %prep
 git clone https://github.com/dhalucario/ly.git ly
 cd ly
 # git checkout v0.5.2
 make github
 %build
 cd ly
 make
 %install
 cd ly
 mkdir -p %{buildroot}/etc/
 mkdir -p %{buildroot}/usr/bin/
 mkdir -p %{buildroot}/usr/lib/systemd/system/
 mkdir -p %{buildroot}/etc/pam.d/
 DESTDIR="%{buildroot}" make install
 DESTDIR="%{buildroot}" make installselinux
 chmod -x %{buildroot}/etc/ly/config.ini
 chmod -x %{buildroot}/etc/ly/lang/*
 %post
 semodule -n -i /usr/share/selinux/packages/ly.pp
 if /usr/sbin/selinuxenabled ; then
    /usr/sbin/load_policy
    %relabel_files
 fi;
 exit 0
 %postun
 if [ $1 -eq 0 ]; then
    semodule -n -r ly
 fi;
 exit 0
 %files
 /usr/bin/ly
 /usr/lib/systemd/system/ly.service
 /etc/ly/lang/es.ini
 /etc/ly/lang/pt.ini
 /etc/ly/lang/ru.ini
 /etc/ly/lang/en.ini
 /etc/ly/lang/fr.ini
 /etc/ly/lang/ro.ini
 /etc/ly/xsetup.sh
 /etc/ly/wsetup.sh
 /etc/ly/config.ini
 /etc/pam.d/ly
 /usr/share/selinux/packages/ly.pp
 %changelog
 {{{ git_dir_changelog }}}
--- a/132
+++ b/132
@@ -0,0 +1,132 @@
 NAME = ly
 CC = gcc
 FLAGS = -std=c99 -pedantic -g
 FLAGS+= -Wall -Wextra -Werror=vla -Wno-unused-parameter
 #FLAGS+= -DDEBUG
 FLAGS+= -DGIT_VERSION_STRING=\"$(shell git describe --long --tags | sed 's/\([^-]*-g\)/r\1/;s/-/./g')\"
 LINK = -lpam -lxcb
 VALGRIND = --show-leak-kinds=all --track-origins=yes --leak-check=full --suppressions=../res/valgrind.supp
 CMD = ./$(NAME)
 OS:= $(shell uname -s)
 ifeq ($(OS), Linux)
 	FLAGS+= -D_DEFAULT_SOURCE
 endif
 BIND = bin
 OBJD = obj
 SRCD = src
 SUBD = sub
 RESD = res
 TESTD = tests
 DATADIR ?= ${DESTDIR}/etc/ly
 FLAGS+= -DDATADIR=\"$(DATADIR)\"
 INCL = -I$(SRCD)
 INCL+= -I$(SUBD)/ctypes
 INCL+= -I$(SUBD)/argoat/src
 INCL+= -I$(SUBD)/configator/src
 INCL+= -I$(SUBD)/dragonfail/src
 INCL+= -I$(SUBD)/termbox_next/src
 SRCS = $(SRCD)/main.c
 SRCS += $(SRCD)/config.c
 SRCS += $(SRCD)/draw.c
 SRCS += $(SRCD)/inputs.c
 SRCS += $(SRCD)/login.c
 SRCS += $(SRCD)/utils.c
 SRCS += $(SUBD)/argoat/src/argoat.c
 SRCS += $(SUBD)/configator/src/configator.c
 SRCS += $(SUBD)/dragonfail/src/dragonfail.c
 SRCS_OBJS:= $(patsubst %.c,$(OBJD)/%.o,$(SRCS))
 SRCS_OBJS+= $(SUBD)/termbox_next/bin/termbox.a
 .PHONY: final
 final: $(BIND)/$(NAME)
 $(OBJD)/%.o: %.c
 	@echo "building object $@"
 	@mkdir -p $(@D)
 	@$(CC) $(INCL) $(FLAGS) -c -o $@ $<
 $(SUBD)/termbox_next/bin/termbox.a:
 	@echo "building static object $@"
 	@(cd $(SUBD)/termbox_next && $(MAKE))
 $(BIND)/$(NAME): $(SRCS_OBJS)
 	@echo "compiling executable $@"
 	@mkdir -p $(@D)
 	@$(CC) -o $@ $^ $(LINK)
 run:
 	@cd $(BIND) && $(CMD)
 leak: leakgrind
 leakgrind: $(BIND)/$(NAME)
 	@rm -f valgrind.log
 	@cd $(BIND) && valgrind $(VALGRIND) 2> ../valgrind.log $(CMD)
 	@less valgrind.log
 install: $(BIND)/$(NAME)
 	@echo "installing"
 	@install -dZ ${DESTDIR}/etc/ly
 	@install -DZ $(BIND)/$(NAME) -t ${DESTDIR}/usr/bin
 	@install -DZ $(RESD)/config.ini -t ${DESTDIR}/etc/ly
 	@install -DZ $(RESD)/xsetup.sh -t $(DATADIR)
 	@install -DZ $(RESD)/wsetup.sh -t $(DATADIR)
 	@install -dZ $(DATADIR)/lang
 	@install -DZ $(RESD)/lang/* -t $(DATADIR)/lang
 	@install -DZ $(RESD)/ly.service -m 644 -t ${DESTDIR}/usr/lib/systemd/system
 	@install -DZ $(RESD)/pam.d/ly -m 644 -t ${DESTDIR}/etc/pam.d
 installnoconf: $(BIND)/$(NAME)
 	@echo "installing without the configuration file"
 	@install -dZ ${DESTDIR}/etc/ly
 	@install -DZ $(BIND)/$(NAME) -t ${DESTDIR}/usr/bin
 	@install -DZ $(RESD)/xsetup.sh -t $(DATADIR)
 	@install -DZ $(RESD)/wsetup.sh -t $(DATADIR)
 	@install -dZ $(DATADIR)/lang
 	@install -DZ $(RESD)/lang/* -t $(DATADIR)/lang
 	@install -DZ $(RESD)/ly.service -m 644 -t ${DESTDIR}/usr/lib/systemd/system
 	@install -DZ $(RESD)/pam.d/ly -m 644 -t ${DESTDIR}/etc/pam.d
 installselinux:
 	@echo "installing selinux modules"
 	@make -f /usr/share/selinux/devel/Makefile ly.pp
 	@install -DZ ly.pp ${DESTDIR}/usr/share/selinux/packages/ly.pp
 uninstall:
 	@echo "uninstalling"
 	@rm -rf ${DESTDIR}/etc/ly
 	@rm -rf $(DATADIR)
 	@rm -f ${DESTDIR}/usr/bin/ly
 	@rm -f ${DESTDIR}/usr/lib/systemd/system/ly.service
 	@rm -f ${DESTDIR}/etc/pam.d/ly
 clean:
 	@echo "cleaning"
 	@rm -rf $(BIND) $(OBJD) valgrind.log
 	@(cd $(SUBD)/termbox_next && $(MAKE) clean)
 remotes:
 	@echo "registering remotes"
 	@git remote add github git@github.com:nullgemm/$(NAME).git
 	@git remote add gitea ssh://git@git.nullgem.fr:2999/nullgemm/$(NAME).git
 github:
 	@echo "sourcing submodules from https://github.com"
 	@cp .github .gitmodules
 	@git submodule sync
 	@git submodule update --init --remote
 	@cd $(SUBD)/argoat && make github
 	@git submodule update --init --recursive --remote
 gitea:
 	@echo "sourcing submodules from personal server"
 	@cp .gitea .gitmodules
 	@git submodule sync
 	@git submodule update --init --remote
 	@cd $(SUBD)/argoat && make gitea
 	@git submodule update --init --recursive --remote
--- a/readme.md
+++ b/readme.md
@@ -1,60 +1,39 @@
 # Ly - a TUI display manager
 ![Ly screenshot](https://user-images.githubusercontent.com/5473047/88958888-65efbf80-d2a1-11ea-8ae5-3f263bce9cce.png "Ly screenshot")
 Ly is a lightweight TUI (ncurses-like) display manager for Linux and BSD.
 ## Dependencies
- Compile-time:
+ - a C99 compiler (tested with tcc and gcc)
-  - zig 0.12.0 or 0.13.0
+ - a C standard library
-  - a C standard library
+ - GNU make
-  - pam
+ - pam
-  - xcb
+ - xcb
- Runtime (with default config):
+ - xorg
-  - xorg
+ - xorg-xauth
-  - xorg-xauth
+ - mcookie
-  - mcookie
+ - tput
-  - tput
+ - shutdown
  - shutdown
-### Debian
+On Debian-based distros running `apt install build-essential libpam0g-dev libxcb-xkb-dev` as root should install all the dependencies for you.
 ```
 # apt install build-essential libpam0g-dev libxcb-xkb-dev
 ```
 ### Fedora
 **Warning**: You may encounter issues with SELinux on Fedora.
 It is recommended to add a rule for Ly as it currently does not ship one.
 ```
 # dnf install kernel-devel pam-devel libxcb-devel
 ```
 ## Support
-The following desktop environments were tested with success:
+The following desktop environments were tested with success
 - awesome
 - bspwm
 - budgie
 - cinnamon
 - deepin
 - dwl
 - dwm
 - enlightenment
 - gnome
 - i3
 - kde
 - labwc
 - lxde
 - lxqt
 - mate
 - maxx
 - pantheon
 - qtile
 - spectrwm
 - sway
 - windowmaker
 - xfce
- - xmonad
+ - pantheon
 - maxx
 - windowmaker
 Ly should work with any X desktop environment, and provides
 basic wayland support (sway works very well, for example).
@@ -68,104 +47,39 @@ changing the source code won't be necessary :)
 ## Cloning and Compiling
 Clone the repository
 ```
-$ git clone https://github.com/fairyglade/ly
+git clone https://github.com/nullgemm/ly.git
 ```
-Change the directory to ly
+Fetch submodules
 ```
-$ cd ly
+make github
 ```
 Compile
 ```
-$ zig build
+make
 ```
 Test in the configured tty (tty2 by default)
 or a terminal emulator (but desktop environments won't start)
 ```
-# zig build run
+sudo make run
 ```
 Install Ly and the provided systemd service file
 ```
-# zig build installsystemd
+sudo make install
 ```
 Enable the service
 ```
-# systemctl enable ly.service
+sudo systemctl enable ly.service
 ```
 If you need to switch between ttys after Ly's start you also have to
 disable getty on Ly's tty to prevent "login" from spawning on top of it
 ```
-# systemctl disable getty@tty2.service
+sudo systemctl disable getty@tty2.service
 ```
 ### OpenRC
 **NOTE**: On Gentoo, Ly will disable the `display-manager-init` service in order to run.
 Clone, compile and test.
 Install Ly and the provided OpenRC service
 ```
 # zig build installopenrc
 ```
 Enable the service
 ```
 # rc-update add ly
 ```
 You can edit which tty Ly will start on by editing the `tty` option in the configuration file.
 If you choose a tty that already has a login/getty running (has a basic login prompt),
 then you have to disable getty, so it doesn't respawn on top of ly
 ```
 # rc-update del agetty.tty2
 ```
 ### runit
 ```
 # zig build installrunit
 # ln -s /etc/sv/ly /var/service/
 ```
 By default, ly will run on tty2. To change the tty it must be set in `/etc/ly/config.ini`
 You should as well disable your existing display manager service if needed, e.g.:
 ```
 # rm /var/service/lxdm
 ```
 The agetty service for the tty console where you are running ly should be disabled.
 For instance, if you are running ly on tty2 (that's the default, check your `/etc/ly/config.ini`)
 you should disable the agetty-tty2 service like this:
 ```
 # rm /var/service/agetty-tty2
 ```
 ### Updating
 You can also install Ly without copying the system service and the configuration file. That's
 called *updating*. To update, simply run:
 ```
 # zig build installnoconf
 ```
 If you want to also copy the default config file (but still not the system service), run:
 ```
 # zig build installexe
 ```
 ## Arch Linux Installation
 You can install ly from the [`[extra]` repos](https://archlinux.org/packages/extra/x86_64/ly/):
 ```
 $ sudo pacman -S ly
 ```
 ## Configuration
@@ -180,10 +94,12 @@ while on the desktop field (above the login field).
 ## .xinitrc
 If your .xinitrc doesn't work make sure it is executable and includes a shebang.
 This file is supposed to be a shell script! Quoting from xinit's man page:
-
+```
-> If no specific client program is given on the command line, xinit will look for a file in the user's home directory called .xinitrc to run as a shell script to start up client programs.
+If no specific client program is given on the command line, xinit will look for
-
+a file in the user's home directory called .xinitrc to run as a shell script to
-On Arch Linux, the example .xinitrc (/etc/X11/xinit/xinitrc) starts like this:
+start up client programs.
 ```
 On ArchLinux, the example .xinitrc (/etc/X11/xinit/xinitrc) starts like this:
 ```
 #!/bin/sh
 ```
@@ -196,12 +112,9 @@ Take a look at your .xsession if X doesn't start, as it can interfere
 ## PSX DOOM fire animation
 To enable the famous PSX DOOM fire described by [Fabien Sanglard](http://fabiensanglard.net/doom_fire_psx/index.html),
-just set `animation = doom` in `/etc/ly/config.ini`. You may also
+just uncomment `animate = true` in `/etc/ly/config.ini`. You may also
 disable the main box borders with `hide_borders = true`.
 ## Additional Information
 The name "Ly" is a tribute to the fairy from the game Rayman.
 Ly was tested by oxodao, who is some seriously awesome dude.
 ## Gentoo (OpenRC) installation tip
 To avoid a console spawning on top on Ly, comment out the appropriate line from /etc/inittab (default is 2).
--- a/res/config.ini
+++ b/res/config.ini
@@ -1,162 +1,104 @@
-# The active animation
+# animation enabled
-# none   -> Nothing (default)
+#animate = false
-# doom   -> PSX DOOM fire
+#animate = true
 # matrix -> CMatrix
 animation = none
-# Format string for clock in top right corner (see strftime specification). Example: %c
+# the active animation (only animation '0' available for now)
-clock = null
+#animation = 0
-# Enable/disable big clock
+# the char used to mask the password
-bigclock = false
+#asterisk = *
 #asterisk = o
-# The character used to mask the password
+# background color id
-asterisk = *
+#bg = 0
-# Erase password input on failure
+# blank main box
-clear_password = false
+#blank_box = true
-# Enable vi keybindings
+# erase password input on failure
-vi_mode = false
+#blank_password = false
 #blank_password = true
-# The `fg` and `bg` color settings take a digit 0-8 corresponding to:
+# console path
-#define TB_DEFAULT 0x00
+#console_dev = /dev/console
 #define TB_BLACK   0x01
 #define TB_RED     0x02
 #define TB_GREEN   0x03
 #define TB_YELLOW  0x04
 #define TB_BLUE    0x05
 #define TB_MAGENTA 0x06
 #define TB_CYAN    0x07
 #define TB_WHITE   0x08
 #
 # Setting both to zero makes `bg` black and `fg` white. To set the actual color palette you are encouraged to use another tool
 # such as [mkinitcpio-colors](https://github.com/evanpurkhiser/mkinitcpio-colors). Note that the color palette defined with
 # `mkinitcpio-colors` takes 16 colors (0-15), only values 0-8 are valid for `ly` config and these values do not correspond
 # exactly. For instance, in defining palettes with `mkinitcpio-colors` the order is black, dark red, dark green, brown, dark
 # blue, dark purple, dark cyan, light gray, dark gray, bright red, bright green, yellow, bright blue, bright purple, bright
 # cyan, and white, indexed in that order 0 through 15. For example, the color defined for white (indexed at 15 in the mkinitcpio
 # config) will be used by `ly` for `fg = 8`.
-# Background color id
+# input active by default on startup
-bg = 0
+#default_input = 2
-# Foreground color id
+# foreground color id
-fg = 8
+#fg = 9
-# Border color
+# remove main box borders
-border_fg = 8
+#hide_borders = false
 #hide_borders = true
-# Title to show at the top of the main box
+# number of visible chars on an input
-box_title = null
+#input_len = 34
-# Initial text to show on the info line (Defaults to hostname)
+# active language
-initial_info_text = null
+#lang = en
 #lang = fr
-# Blank main box background
+# load the saved desktop and login
-# Setting to false will make it transparent
+#load = true
 blank_box = true
-# Remove main box borders
+# main box margins
-hide_borders = false
+#margin_box_h = 2
 #margin_box_v = 1
-# Main box margins
+# total input sizes
-margin_box_h = 2
+#max_desktop_len = 100
-margin_box_v = 1
+#max_login_len = 255
 #max_password_len = 255
-# Input boxes length
+# cookie generator
-input_len = 34
+#mcookie_cmd = /usr/bin/mcookie
-# Max input sizes
+# event timeout in milliseconds
-max_desktop_len = 100
+#min_refresh_delta = 5
 max_login_len = 255
 max_password_len = 255
-# Input box active by default on startup
+# default path
-# Available inputs: session, login, password
+#path = /sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin
 default_input = login
-# Load the saved desktop and username
+# command executed when pressing F2
-load = true
+#restart_cmd = /sbin/shutdown -r now
-# Save the current desktop and login as defaults
+# save the current desktop and login as defaults
-save = true
+#save = true
-# Deprecated - Will be removed in a future version
+# file in which to save and load the default desktop and login
-# New save files are now loaded from the same directory as the config
+#save_file = /etc/ly/save
 # Currently used to migrate old save files to the new version
 # File in which to save and load the default desktop and login
 save_file = /etc/ly/save
-# Remove power management command hints
+# service name (set to ly to use the provided pam config file)
-hide_key_hints = false
+#service_name = ly
-# Specifies the key used for shutdown (F1-F12)
+# command executed when pressing F1
-shutdown_key = F1
+#shutdown_cmd = /sbin/shutdown -a now
-# Specifies the key used for restart (F1-F12)
+# terminal reset command (tput is faster)
-restart_key = F2
+#term_reset_cmd = /usr/bin/tput reset
-# Specifies the key used for sleep (F1-F12)
+# tty in use
-sleep_key = F3
+#tty = 2
-# Command executed when pressing shutdown_key
+# wayland setup command
-shutdown_cmd = /sbin/shutdown -a now
+#wayland_cmd = /etc/ly/wsetup.sh
-# Command executed when pressing restart_key
+# add wayland specifier to session names
-restart_cmd = /sbin/shutdown -r now
+#wayland_specifier = false
 #wayland_specifier = true
-# Command executed when pressing sleep key (can be null)
+# wayland desktop environments
-sleep_cmd = null
+#waylandsessions = /usr/share/wayland-sessions
-# Active language
+# xorg server command
-# Available languages are found in /etc/ly/lang/
+#x_cmd = /usr/bin/X
 lang = en
-# TTY in use
+# xorg setup command
-tty = 2
+#x_cmd_setup = /etc/ly/xsetup.sh
-# Console path
+# xorg xauthority edition tool
-console_dev = /dev/console
+#xauth_cmd = /usr/bin/xauth
-# Default path. If null, ly doesn't set a path.
+# xorg desktop environments
-path = /sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin
+#xsessions = /usr/share/xsessions
 # Event timeout in milliseconds
 min_refresh_delta = 5
 # Set numlock on/off at startup
 numlock = false
 # Service name (set to ly to use the provided pam config file)
 service_name = ly
 # Terminal reset command (tput is faster)
 term_reset_cmd = /usr/bin/tput reset
 # Terminal restore cursor command
 term_restore_cursor_cmd = /usr/bin/tput cnorm
 # Cookie generator
 mcookie_cmd = /usr/bin/mcookie
 # Wayland setup command
 wayland_cmd = /etc/ly/wsetup.sh
 # Wayland desktop environments
 waylandsessions = /usr/share/wayland-sessions
 # xinitrc (hidden if null)
 xinitrc = ~/.xinitrc
 # Xorg server command
 x_cmd = /usr/bin/X
 # Xorg setup command
 x_cmd_setup = /etc/ly/xsetup.sh
 # Xorg xauthority edition tool
 xauth_cmd = /usr/bin/xauth
 # Xorg desktop environments
 xsessions = /usr/share/xsessions
--- a/res/lang/cat.ini
+++ b/res/lang/cat.ini
@@ -1,45 +0,0 @@
 capslock = Bloq Majús
 err_alloc = falla d'assignació de memòria
 err_bounds = índex fora de límit
 err_chdir = error al obrir carpeta home
 err_console_dev = error al accedir a la consola
 err_dgn_oob = missatge de registre
 err_domain = domini invàlid
 err_hostname = error al obtenir el nom del host
 err_mlock = error al bloquejar la clau de memòria
 err_null = punter nul
 err_pam = error en la transacció pam
 err_pam_abort = transacció pam avortada
 err_pam_acct_expired = compte expirat
 err_pam_auth = error d'autenticació
 err_pam_authinfo_unavail = error al obtenir informació de l'usuari
 err_pam_authok_reqd = token expirat
 err_pam_buf = error de la memòria intermitja
 err_pam_cred_err = error al establir les credencials
 err_pam_cred_expired = credencials expirades
 err_pam_cred_insufficient = credencials insuficients
 err_pam_cred_unavail = error al obtenir credencials
 err_pam_maxtries = s'ha assolit al màxim nombre d'intents
 err_pam_perm_denied = permís denegat
 err_pam_session = error de sessió
 err_pam_sys = error de sistema
 err_pam_user_unknown = usuari desconegut
 err_path = error al establir la ruta
 err_perm_dir = error al canviar de directori actual
 err_perm_group = error al degradar els permisos de grup
 err_perm_user = error al degradar els permisos de l'usuari
 err_pwnam = error al obtenir la informació de l'usuari
 err_user_gid = error al establir el GID de l'usuari
 err_user_init = error al inicialitzar usuari
 err_user_uid = error al establir el UID de l'usuari
 err_xsessions_dir = error al cercar la carpeta de sessions
 err_xsessions_open = error al obrir la carpeta de sessions
 login = iniciar sessió
 logout = tancar sessió
 numlock = Bloq Num
 password = Clau
 restart = reiniciar
 shell = shell
 shutdown = aturar
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/cs.ini
+++ b/res/lang/cs.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = alokace paměti selhala
 err_bounds = index je mimo hranice pole
 err_chdir = nelze otevřít domovský adresář
 err_console_dev = chyba při přístupu do konzole
 err_dgn_oob = zpráva protokolu
 err_domain = neplatná doména
 err_hostname = nelze získat název hostitele
 err_mlock = uzamčení paměti hesel selhalo
 err_null = nulový ukazatel
 err_pam = pam transakce selhala
 err_pam_abort = pam transakce přerušena
 err_pam_acct_expired = platnost účtu vypršela
 err_pam_auth = chyba autentizace
 err_pam_authinfo_unavail = nelze získat informace o uživateli
 err_pam_authok_reqd = platnost tokenu vypršela
 err_pam_buf = chyba vyrovnávací paměti
 err_pam_cred_err = nelze nastavit pověření
 err_pam_cred_expired = platnost pověření vypršela
 err_pam_cred_insufficient = nedostatečné pověření
 err_pam_cred_unavail = nepodařilo se získat pověření
 err_pam_maxtries = byl dosažen maximální počet pokusů
 err_pam_perm_denied = přístup odepřen
 err_pam_session = chyba relace
 err_pam_sys = systemová chyba
 err_pam_user_unknown = neznámý uživatel
 err_path = nepodařilo se nastavit cestu
 err_perm_dir = nepodařilo se změnit adresář
 err_perm_group = nepodařilo se snížit skupinová oprávnění
 err_perm_user = nepodařilo se snížit uživatelská oprávnění
 err_pwnam = nelze získat informace o uživateli
 err_user_gid = nastavení GID uživatele selhalo
 err_user_init = inicializace uživatele selhala
 err_user_uid = nastavení UID uživateli selhalo
 err_xsessions_dir = nepodařilo se najít složku relací
 err_xsessions_open = nepodařilo se otevřít složku relací
 login = uživatel
 logout = odhlášen
 numlock = numlock
 password = heslo
 restart = restartovat
 shell = příkazový řádek
 shutdown = vypnout
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/de.ini
+++ b/res/lang/de.ini
@@ -1,45 +0,0 @@
 capslock = Feststelltaste
 err_alloc = Speicherzuweisung fehlgeschlagen
 err_bounds = Listenindex ist außerhalb des Bereichs
 err_chdir = Fehler beim oeffnen des home-ordners
 err_console_dev = Zugriff auf die Konsole fehlgeschlagen
 err_dgn_oob = Protokoll Nachricht
 err_domain = Unzulaessige domain
 err_hostname = Holen des Hostnames fehlgeschlagen
 err_mlock = Abschließen des Passwortspeichers fehlgeschlagen
 err_null = Null Zeiger
 err_pam = pam Transaktion fehlgeschlagen
 err_pam_abort = pam Transaktion abgebrochen
 err_pam_acct_expired = Benutzerkonto abgelaufen
 err_pam_auth = Authentifizierungs Fehler
 err_pam_authinfo_unavail = holen der Benutzerinformationen fehlgeschlagen
 err_pam_authok_reqd = Schluessel abgelaufen
 err_pam_buf = Speicherpufferfehler
 err_pam_cred_err = Fehler beim setzen der Anmeldedaten
 err_pam_cred_expired = Anmeldedaten abgelaufen
 err_pam_cred_insufficient = Anmeldedaten unzureichend
 err_pam_cred_unavail = Fehler beim holen der Anmeldedaten
 err_pam_maxtries = Maximale Versuche erreicht
 err_pam_perm_denied = Zugriff Verweigert
 err_pam_session = Sitzungsfehler
 err_pam_sys = Systemfehler
 err_pam_user_unknown = Unbekannter Nutzer
 err_path = Fehler beim setzen des Pfades
 err_perm_dir = Fehler beim wechseln des Ordners
 err_perm_group = Fehler beim heruntersetzen der Gruppen Berechtigungen
 err_perm_user = Fehler beim heruntersetzen der Nutzer Berechtigungen
 err_pwnam = Holen der Benutzerinformationen fehlgeschlagen
 err_user_gid = Fehler beim setzen der Gruppen Id des Nutzers
 err_user_init = Initialisierung des Nutzers fehlgeschlagen
 err_user_uid = Setzen der Benutzer Id fehlgeschlagen
 err_xsessions_dir = Fehler beim finden des Sitzungsordners
 err_xsessions_open = Fehler beim öffnen des Sitzungsordners
 login = Anmelden
 logout = Abgemeldet
 numlock = Numtaste
 password = Passwort
 restart = Neustarten
 shell = shell
 shutdown = Herunterfahren
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/en.ini
+++ b/res/lang/en.ini
@@ -1,4 +1,3 @@
 authenticating = authenticating...
 capslock = capslock
 err_alloc = failed memory allocation
 err_bounds = out-of-bounds index
@@ -6,9 +5,7 @@ err_chdir = failed to open home folder
 err_console_dev = failed to access console
 err_dgn_oob = log message
 err_domain = invalid domain
 err_envlist = failed to get envlist
 err_hostname = failed to get hostname
 err_mcookie = mcookie command failed
 err_mlock = failed to lock password memory
 err_null = null pointer
 err_pam = pam transaction failed
@@ -32,24 +29,17 @@ err_perm_dir = failed to change current directory
 err_perm_group = failed to downgrade group permissions
 err_perm_user = failed to downgrade user permissions
 err_pwnam = failed to get user info
 err_unknown = an unknown error occurred
 err_user_gid = failed to set user GID
 err_user_init = failed to initialize user
 err_user_uid = failed to set user UID
 err_xauth = xauth command failed
 err_xcb_conn = xcb connection failed
 err_xsessions_dir = failed to find sessions folder
 err_xsessions_open = failed to open sessions folder
-insert = insert
+f1 = F1 shutdown
-login = login
+f2 = F2 reboot
 login = login:
 logout = logged out
 normal = normal
 numlock = numlock
-password = password
+password = password:
 restart = reboot
 shell = shell
 shutdown = shutdown
 sleep = sleep
 wayland = wayland
 xinitrc = xinitrc
 x11 = x11
--- a/res/lang/es.ini
+++ b/res/lang/es.ini
@@ -15,7 +15,7 @@ err_pam_auth = error de autenticación
 err_pam_authinfo_unavail = error al obtener información del usuario
 err_pam_authok_reqd = token expirado
 err_pam_buf = error de la memoria intermedia
-err_pam_cred_err = error al establecer las credenciales
+err_pam_cred_err = error al establecer la credenciales
 err_pam_cred_expired = credenciales expiradas
 err_pam_cred_insufficient = credenciales insuficientes
 err_pam_cred_unavail = error al obtener credenciales
@@ -30,16 +30,16 @@ err_perm_group = error al degradar los permisos del grupo
 err_perm_user = error al degradar los permisos del usuario
 err_pwnam = error al obtener la información del usuario
 err_user_gid = error al establecer el GID del usuario
-err_user_init = error al inicializar usuario
+err_user_init = errpr al inicializar usuario
 err_user_uid = error al establecer el UID del usuario
 err_xsessions_dir = error al buscar la carpeta de sesiones
 err_xsessions_open = error al abrir la carpeta de sesiones
-login = iniciar sesión
+f1 = F1 apagar
-logout = cerrar sesión
+f2 = F2 reiniciar
 login = iniciar sesion:
 logout = cerrar sesion
 numlock = Bloq Num 
-password = contraseña
+password = contraseña:
 restart = reiniciar
 shell = shell
 shutdown = apagar
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/fr.ini
+++ b/res/lang/fr.ini
@@ -5,7 +5,7 @@ err_chdir = échec de l'ouverture du répertoire home
 err_console_dev = échec d'accès à la console
 err_dgn_oob = message
 err_domain = domaine invalide
-err_hostname = échec de lecture du nom d'hôte
+err_hostname = échec de captation du nom d'hôte
 err_mlock = échec du verrouillage mémoire
 err_null = pointeur null
 err_pam = échec de la transaction pam
@@ -28,18 +28,18 @@ err_path = échec de la modification du path
 err_perm_dir = échec de changement de répertoire
 err_perm_group = échec du déclassement des permissions de groupe
 err_perm_user = échec du déclassement des permissions utilisateur
-err_pwnam = échec de lecture des infos utilisateur
+err_pwnam = échec de captation des infos utilisateur
 err_user_gid = échec de modification du GID
 err_user_init = échec d'initialisation de l'utilisateur
 err_user_uid = échec de modification du UID
 err_xsessions_dir = échec de la recherche du dossier de sessions
 err_xsessions_open = échec de l'ouverture du dossier de sessions
-login = identifiant
+f1 = F1 éteindre
 f2 = F2 redémarrer
 login = identifiant :
 logout = déconnection
 numlock = verr.num
-password = mot de passe
+password = mot de passe :
 restart = redémarrer
 shell = shell
 shutdown = éteindre
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/it.ini
+++ b/res/lang/it.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = impossibile allocare memoria
 err_bounds = indice fuori limite
 err_chdir = impossibile aprire home directory
 err_console_dev = impossibile aprire console
 err_dgn_oob = messaggio log
 err_domain = dominio non valido
 err_hostname = impossibile ottenere hostname
 err_mlock = impossibile ottenere lock per la password in memoria
 err_null = puntatore nullo
 err_pam = transazione PAM fallita
 err_pam_abort = transazione PAM interrotta
 err_pam_acct_expired = account scaduto
 err_pam_auth = errore di autenticazione
 err_pam_authinfo_unavail = impossibile ottenere informazioni utente
 err_pam_authok_reqd = token scaduto
 err_pam_buf = errore buffer memoria
 err_pam_cred_err = impossibile impostare credenziali
 err_pam_cred_expired = credenziali scadute
 err_pam_cred_insufficient = credenziali insufficienti
 err_pam_cred_unavail = impossibile ottenere credenziali
 err_pam_maxtries = raggiunto limite tentativi
 err_pam_perm_denied = permesso negato
 err_pam_session = errore di sessione
 err_pam_sys = errore di sistema
 err_pam_user_unknown = utente sconosciuto
 err_path = impossibile impostare percorso
 err_perm_dir = impossibile cambiare directory corrente
 err_perm_group = impossibile ridurre permessi gruppo
 err_perm_user = impossibile ridurre permessi utente
 err_pwnam = impossibile ottenere dati utente
 err_user_gid = impossibile impostare GID utente
 err_user_init = impossibile inizializzare utente
 err_user_uid = impossible impostare UID utente
 err_xsessions_dir = impossibile localizzare cartella sessioni
 err_xsessions_open = impossibile aprire cartella sessioni
 login = username
 logout = scollegato
 numlock = numlock
 password = password
 restart = riavvio
 shell = shell
 shutdown = arresto
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/pl.ini
+++ b/res/lang/pl.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = nieudana alokacja pamięci
 err_bounds = indeks poza granicami
 err_chdir = nie udało się otworzyć folderu domowego
 err_console_dev = nie udało się uzyskać dostępu do konsoli
 err_dgn_oob = wiadomość loga
 err_domain = niepoprawna domena
 err_hostname = nie udało się uzyskać nazwy hosta
 err_mlock = nie udało się zablokować pamięci haseł
 err_null = wskaźnik zerowy
 err_pam = transakcja pam nieudana
 err_pam_abort = transakcja pam przerwana
 err_pam_acct_expired = konto wygasło
 err_pam_auth = błąd autentyfikacji
 err_pam_authinfo_unavail = nie udało się zdobyć informacji o użytkowniku
 err_pam_authok_reqd = token wygasł
 err_pam_buf = błąd bufora pamięci
 err_pam_cred_err = nie udało się ustawić uwierzytelnienia
 err_pam_cred_expired = uwierzytelnienie wygasło
 err_pam_cred_insufficient = niewystarczające uwierzytelnienie
 err_pam_cred_unavail = nie udało się uzyskać uwierzytelnienia
 err_pam_maxtries = osiągnięto limit prób
 err_pam_perm_denied = brak uprawnień
 err_pam_session = błąd sesji
 err_pam_sys = błąd systemu
 err_pam_user_unknown = nieznany użytkownik
 err_path = nie udało się ustawić ścieżki
 err_perm_dir = nie udało się zmienić obecnego katalogu
 err_perm_group = nie udało się obniżyć uprawnień grupy
 err_perm_user = nie udało się obniżyć uprawnień użytkownika
 err_pwnam = nie udało się uzyskać informacji o użytkowniku
 err_user_gid = nie udało się ustawić GID użytkownika
 err_user_init = nie udało się zainicjalizować użytkownika
 err_user_uid = nie udało się ustawić UID użytkownika
 err_xsessions_dir = nie udało się znaleźć folderu sesji
 err_xsessions_open = nie udało się otworzyć folderu sesji
 login = login
 logout = wylogowano
 numlock = numlock
 password = hasło
 restart = uruchom ponownie
 shell = powłoka
 shutdown = wyłącz
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/pt.ini
+++ b/res/lang/pt.ini
@@ -1,45 +1,45 @@
-capslock = capslock
+capslock = caixa alta
-err_alloc = erro na atribuição de memória
+err_alloc = alocação de memória malsucedida
 err_bounds = índice fora de limites
-err_chdir = erro ao abrir a pasta home
+err_chdir = não foi possível abrir o diretório home
-err_console_dev = erro ao aceder à consola
+err_console_dev = não foi possível acessar o console
-err_dgn_oob = mensagem de registo
+err_dgn_oob = mensagem de log
 err_domain = domínio inválido
-err_hostname = erro ao obter o nome do host
+err_hostname = não foi possível obter o nome do host
-err_mlock = erro de bloqueio de memória
+err_mlock = bloqueio da memória de senha malsucedido
 err_null = ponteiro nulo
-err_pam = erro na transação pam
+err_pam = transação pam malsucedida
 err_pam_abort = transação pam abortada
 err_pam_acct_expired = conta expirada
 err_pam_auth = erro de autenticação
-err_pam_authinfo_unavail = erro ao obter informação do utilizador
+err_pam_authinfo_unavail = não foi possível obter informações do usuário
-err_pam_authok_reqd = token expirado
+err_pam_authok_reqd = token expirada
 err_pam_buf = erro de buffer de memória
-err_pam_cred_err = erro ao definir credenciais
+err_pam_cred_err = erro para definir credenciais
 err_pam_cred_expired = credenciais expiradas
 err_pam_cred_insufficient = credenciais insuficientes
-err_pam_cred_unavail = erro ao obter credenciais
+err_pam_cred_unavail = não foi possível obter credenciais
 err_pam_maxtries = limite máximo de tentativas atingido
 err_pam_perm_denied = permissão negada
 err_pam_session = erro de sessão
 err_pam_sys = erro de sistema
-err_pam_user_unknown = utilizador desconhecido
+err_pam_user_unknown = usuário desconhecido
-err_path = erro ao definir o caminho de acesso
+err_path = não foi possível definir o caminho
-err_perm_dir = erro ao alterar o diretório atual
+err_perm_dir = não foi possível alterar o diretório atual
-err_perm_group = erro ao reduzir as permissões do grupo
+err_perm_group = não foi possível reduzir as permissões de grupo
-err_perm_user = erro ao reduzir as permissões do utilizador
+err_perm_user = não foi possível reduzir as permissões de usuário
-err_pwnam = erro ao obter informação do utilizador
+err_pwnam = não foi possível obter informações do usuário
-err_user_gid = erro ao definir o GID do utilizador
+err_user_gid = não foi possível definir o GID do usuário
-err_user_init = erro ao iniciar o utilizador
+err_user_init = não foi possível iniciar o usuário
-err_user_uid = erro ao definir o UID do utilizador
+err_user_uid = não foi possível definir o UID do usuário
-err_xsessions_dir = erro ao localizar a pasta das sessões
+err_xsessions_dir = não foi possível encontrar a pasta das sessões
-err_xsessions_open = erro ao abrir a pasta das sessões
+err_xsessions_open = não foi possível abrir a pasta das sessões
-login = iniciar sessão
+f1 = F1 desligar
-logout = terminar sessão
+f2 = F2 reiniciar
 login = conectar:
 logout = desconectado
 numlock = numlock
-password = palavra-passe
+password = senha:
 restart = reiniciar
 shell = shell
 shutdown = encerrar
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/pt_BR.ini
+++ b/res/lang/pt_BR.ini
@@ -1,45 +0,0 @@
 capslock = caixa alta
 err_alloc = alocação de memória malsucedida
 err_bounds = índice fora de limites
 err_chdir = não foi possível abrir o diretório home
 err_console_dev = não foi possível acessar o console
 err_dgn_oob = mensagem de log
 err_domain = domínio inválido
 err_hostname = não foi possível obter o nome do host
 err_mlock = bloqueio da memória de senha malsucedido
 err_null = ponteiro nulo
 err_pam = transação pam malsucedida
 err_pam_abort = transação pam abortada
 err_pam_acct_expired = conta expirada
 err_pam_auth = erro de autenticação
 err_pam_authinfo_unavail = não foi possível obter informações do usuário
 err_pam_authok_reqd = token expirada
 err_pam_buf = erro de buffer de memória
 err_pam_cred_err = erro para definir credenciais
 err_pam_cred_expired = credenciais expiradas
 err_pam_cred_insufficient = credenciais insuficientes
 err_pam_cred_unavail = não foi possível obter credenciais
 err_pam_maxtries = limite máximo de tentativas atingido
 err_pam_perm_denied = permissão negada
 err_pam_session = erro de sessão
 err_pam_sys = erro de sistema
 err_pam_user_unknown = usuário desconhecido
 err_path = não foi possível definir o caminho
 err_perm_dir = não foi possível alterar o diretório atual
 err_perm_group = não foi possível reduzir as permissões de grupo
 err_perm_user = não foi possível reduzir as permissões de usuário
 err_pwnam = não foi possível obter informações do usuário
 err_user_gid = não foi possível definir o GID do usuário
 err_user_init = não foi possível iniciar o usuário
 err_user_uid = não foi possível definir o UID do usuário
 err_xsessions_dir = não foi possível encontrar a pasta das sessões
 err_xsessions_open = não foi possível abrir a pasta das sessões
 login = conectar
 logout = desconectado
 numlock = numlock
 password = senha
 restart = reiniciar
 shell = shell
 shutdown = desligar
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/ro.ini
+++ b/res/lang/ro.ini
@@ -34,12 +34,12 @@ err_perm_user = nu s-a putut face downgrade permisiunilor de utilizator
-login = utilizator
+f1 = F1 opreşte sistemul
 f2 = F2 resetează
 login = utilizator:
 logout = opreşte sesiunea
 numlock = numlock
-password = parolă
+password = parolă:
 restart = resetează
 shell = shell
 shutdown = opreşte sistemul
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/ru.ini
+++ b/res/lang/ru.ini
@@ -10,17 +10,17 @@ err_mlock = сбой блокировки памяти
 err_null = нулевой указатель
 err_pam = pam транзакция не удалась
 err_pam_abort = pam транзакция прервана
-err_pam_acct_expired = срок действия аккаунта истёк
+err_pam_acct_expired = срок действия аккаунта истек
 err_pam_auth = ошибка аутентификации
 err_pam_authinfo_unavail = не удалось получить информацию о пользователе
-err_pam_authok_reqd = токен истёк
+err_pam_authok_reqd = токен истек
 err_pam_buf = ошибка буфера памяти
 err_pam_cred_err = не удалось установить полномочия
 err_pam_cred_expired = полномочия истекли
-err_pam_cred_insufficient = недостаточно полномочий
+err_pam_cred_insufficient = недостаточо полномочий
 err_pam_cred_unavail = не удалось получить полномочия
 err_pam_maxtries = лимит попыток исчерпан
-err_pam_perm_denied = доступ запрещён
+err_pam_perm_denied = доступ запрещен
 err_pam_session = ошибка сессии
 err_pam_sys = системная ошибка
 err_pam_user_unknown = неизвестный пользователь
@@ -34,12 +34,12 @@ err_user_init = не удалось инициализировать польз
 err_user_uid = не удалось установить UID пользователя
 err_xsessions_dir = не удалось найти сессионную папку
 err_xsessions_open = не удалось открыть сессионную папку
-login = логин
+f1 = F1 выключить
 f2 = F2 перезагрузить
 login = логин:
 logout = logged out
 numlock = numlock
-password = пароль
+password = пароль:
 restart = перезагрузить
 shell = shell
 shutdown = выключить
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/sr.ini
+++ b/res/lang/sr.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = neuspijesna alokacija memorije
 err_bounds = izvan granica indeksa
 err_chdir = neuspijesno otvaranje home foldera
 err_console_dev = neuspijesno pristupanje konzoli
 err_dgn_oob = log poruka
 err_domain = nevazeci domen
 err_hostname = neuspijesno trazenje hostname-a
 err_mlock = neuspijesno zakljucavanje memorije lozinke
 err_null = null pokazivac
 err_pam = pam transakcija neuspijesna
 err_pam_abort = pam transakcija prekinuta
 err_pam_acct_expired = nalog istekao
 err_pam_auth = greska pri autentikaciji
 err_pam_authinfo_unavail = neuspjelo uzimanje informacija o korisniku
 err_pam_authok_reqd = token istekao
 err_pam_buf = greska bafera memorije
 err_pam_cred_err = neuspjelo postavljanje kredencijala
 err_pam_cred_expired = kredencijali istekli
 err_pam_cred_insufficient = nedovoljni kredencijali
 err_pam_cred_unavail = neuspjelo uzimanje kredencijala
 err_pam_maxtries = dostignut maksimalan broj pokusaja
 err_pam_perm_denied = nedozovoljeno
 err_pam_session = greska sesije
 err_pam_sys = greska sistema
 err_pam_user_unknown = nepoznat korisnik
 err_path = neuspjelo postavljanje path-a
 err_perm_dir = neuspjelo mijenjanje foldera 
 err_perm_group = neuspjesno snizavanje dozvola grupe
 err_perm_user = neuspijesno snizavanje dozvola korisnika
 err_pwnam = neuspijesno skupljanje informacija o korisniku
 err_user_gid = neuspijesno postavljanje korisničkog GID-a
 err_user_init = neuspijensa inicijalizacija korisnika
 err_user_uid = neuspijesno postavljanje UID-a korisnika
 err_xsessions_dir = neuspijesno pronalazenje foldera sesija
 err_xsessions_open = neuspijesno otvaranje foldera sesija 
 login = korisnik
 logout = izlogovan
 numlock = numlock
 password = lozinka
 restart = ponovo pokreni
 shell = shell
 shutdown = ugasi
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/sv.ini
+++ b/res/lang/sv.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = misslyckad minnesallokering
 err_bounds = utanför banan index
 err_chdir = misslyckades att öppna hemkatalog
 err_console_dev = misslyckades att komma åt konsol
 err_dgn_oob = loggmeddelande
 err_domain = okänd domän
 err_hostname = misslyckades att hämta värdnamn
 err_mlock = misslyckades att låsa lösenordsminne
 err_null = nullpekare
 err_pam = pam-transaktion misslyckades
 err_pam_abort = pam-transaktion avbröts
 err_pam_acct_expired = konto upphört
 err_pam_auth = autentiseringsfel
 err_pam_authinfo_unavail = misslyckades att hämta användarinfo
 err_pam_authok_reqd = token utgången
 err_pam_buf = minnesbuffer fel
 err_pam_cred_err = misslyckades att ställa in inloggningsuppgifter
 err_pam_cred_expired = inloggningsuppgifter upphörda
 err_pam_cred_insufficient = otillräckliga inloggningsuppgifter
 err_pam_cred_unavail = misslyckades att hämta inloggningsuppgifter
 err_pam_maxtries = nådde maximal försöksgräns
 err_pam_perm_denied = åtkomst nekad
 err_pam_session = sessionsfel
 err_pam_sys = systemfel
 err_pam_user_unknown = okänd användare
 err_path = misslyckades att ställa in sökväg
 err_perm_dir = misslyckades att ändra aktuell katalog
 err_perm_group = misslyckades att nergradera gruppbehörigheter
 err_perm_user = misslyckades att nergradera användarbehörigheter
 err_pwnam = misslyckades att hämta användarinfo
 err_user_gid = misslyckades att ställa in användar-GID
 err_user_init = misslyckades att initialisera användaren
 err_user_uid = misslyckades att ställa in användar-UID
 err_xsessions_dir = misslyckades att hitta sessionskatalog
 err_xsessions_open = misslyckades att öppna sessionskatalog
 login = inloggning
 logout = utloggad
 numlock = numlock
 password = lösenord
 restart = starta om
 shell = skal
 shutdown = stäng av
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/tr.ini
+++ b/res/lang/tr.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = basarisiz bellek ayirma
 err_bounds = sinirlarin disinda dizin
 err_chdir = ev klasoru acilamadi
 err_console_dev = konsola erisilemedi
 err_dgn_oob = log mesaji
 err_domain = gecersiz etki alani
 err_hostname = ana bilgisayar adi alinamadi
 err_mlock = parola bellegi kilitlenemedi
 err_null = bos isaretci hatasi
 err_pam = pam islemi basarisiz oldu
 err_pam_abort = pam islemi durduruldu
 err_pam_acct_expired = hesabin suresi dolmus
 err_pam_auth = kimlik dogrulama hatasi
 err_pam_authinfo_unavail = kullanici bilgileri getirilirken hata olustu
 err_pam_authok_reqd = suresi dolmus token
 err_pam_buf = bellek arabellegi hatasi
 err_pam_cred_err = kimlik bilgileri ayarlanamadi
 err_pam_cred_expired = kimlik bilgilerinin suresi dolmus
 err_pam_cred_insufficient = yetersiz kimlik bilgileri
 err_pam_cred_unavail = kimlik bilgileri alinamadi
 err_pam_maxtries = en fazla deneme sinirina ulasildi
 err_pam_perm_denied = izin reddedildi
 err_pam_session = oturum hatasi
 err_pam_sys = sistem hatasi
 err_pam_user_unknown = bilinmeyen kullanici
 err_path = yol ayarlanamadi
 err_perm_dir = gecerli dizin degistirilemedi
 err_perm_group = grup izinleri dusurulemedi
 err_perm_user = kullanici izinleri dusurulemedi
 err_pwnam = kullanici bilgileri alinamadi
 err_user_gid = kullanici icin GID ayarlanamadi
 err_user_init = kullanici oturumu baslatilamadi
 err_user_uid = kullanici icin UID ayarlanamadi
 err_xsessions_dir = oturumlar klasoru bulunamadi
 err_xsessions_open = oturumlar klasoru acilamadi
 login = kullanici
 logout = oturumdan cikis yapildi
 numlock = numlock
 password = sifre
 restart = yeniden baslat
 shell = shell
 shutdown = makineyi kapat
 wayland = wayland
 xinitrc = xinitrc
--- a/res/lang/uk.ini
+++ b/res/lang/uk.ini
@@ -1,45 +0,0 @@
 capslock = capslock
 err_alloc = невдале виділення пам'яті
 err_bounds = поза межами індексу
 err_chdir = не вдалося відкрити домашній каталог
 err_console_dev = невдалий доступ до консолі
 err_dgn_oob = повідомлення журналу (log)
 err_domain = недійсний домен
 err_hostname = не вдалося отримати ім'я хосту
 err_mlock = збій блокування пам'яті
 err_null = нульовий вказівник
 err_pam = невдала pam транзакція
 err_pam_abort = pam транзакція перервана
 err_pam_acct_expired = термін дії акаунту вичерпано
 err_pam_auth = помилка автентифікації
 err_pam_authinfo_unavail = не вдалося отримати дані користувача
 err_pam_authok_reqd = термін дії токена вичерпано
 err_pam_buf = помилка буферу пам'яті
 err_pam_cred_err = не вдалося змінити облікові дані
 err_pam_cred_expired = термін дії повноважень вичерпано
 err_pam_cred_insufficient = недостатньо облікових даних
 err_pam_cred_unavail = не вдалося отримати облікові дані
 err_pam_maxtries = вичерпано ліміт спроб
 err_pam_perm_denied = відмовлено у доступі
 err_pam_session = помилка сесії
 err_pam_sys = системна помилка
 err_pam_user_unknown = невідомий користувач
 err_path = не вдалося змінити шлях
 err_perm_dir = не вдалося змінити поточний каталог
 err_perm_group = не вдалося понизити права доступу групи
 err_perm_user = не вдалося понизити права доступу користувача
 err_pwnam = не вдалося отримати дані користувача
 err_user_gid = не вдалося змінити GID користувача
 err_user_init = не вдалося ініціалізувати користувача
 err_user_uid = не вдалося змінити UID користувача
 err_xsessions_dir = не вдалося знайти каталог сесій
 err_xsessions_open = не вдалося відкрити каталог сесій
 login = логін
 logout = вийти
 numlock = numlock
 password = пароль
 restart = перезавантажити
 shell = оболонка
 shutdown = вимкнути
 wayland = wayland
 xinitrc = xinitrc
--- a/res/ly-openrc
+++ b/res/ly-openrc
@@ -1,38 +0,0 @@
 #!/sbin/openrc-run
 name="ly"
 description="TUI Display Manager"
 ## Supervisor daemon
 supervisor=supervise-daemon
 respawn_period=60
 pidfile=/run/"${RC_SVCNAME}.pid"
 ## Check for getty or agetty
 if [ -x /sbin/getty ] || [ -x /bin/getty ];
 then
    # busybox
    commandB="/sbin/getty"
 elif [ -x /sbin/agetty ] || [ -x /bin/agetty ];
 then
    # util-linux
    commandUL="/sbin/agetty"
 fi
 ## Get the tty from the conf file
 CONFTTY=$(cat /etc/ly/config.ini | sed -n 's/^tty.*=[^1-9]*// p')
 ## The execution vars
 # If CONFTTY is empty then default to 2
 TTY="tty${CONFTTY:-2}"
 TERM=linux
 BAUD=38400
 # If we don't have getty then we should have agetty
 command=${commandB:-$commandUL}
 command_args_foreground="-nl /usr/bin/ly $TTY $BAUD $TERM"
 depend() {
         after agetty
         provide display-manager
         want elogind
 }
--- a/res/ly-runit-service/conf
+++ b/res/ly-runit-service/conf
@@ -1,12 +0,0 @@
 if [ -x /sbin/agetty -o -x /bin/agetty ]; then
 	# util-linux specific settings
 	if [ "${tty}" = "tty1" ]; then
 		GETTY_ARGS="--noclear"
 	fi
 fi
 BAUD_RATE=38400
 TERM_NAME=linux
 auxtty=$(/bin/cat /etc/ly/config.ini 2>/dev/null 1| /bin/sed -n 's/\(^[[:space:]]*tty[[:space:]]*=[[:space:]]*\)\([[:digit:]][[:digit:]]*\)\(.*\)/\2/p')
 TTY=tty${auxtty:-2}
--- a/res/ly-runit-service/finish
+++ b/res/ly-runit-service/finish
@@ -1,4 +0,0 @@
 #!/bin/sh
 [ -r conf ] && . ./conf
 exec utmpset -w ${TTY}
--- a/res/ly-runit-service/run
+++ b/res/ly-runit-service/run
@@ -1,13 +0,0 @@
 #!/bin/sh
 [ -r conf ] && . ./conf
 if [ -x /sbin/getty -o -x /bin/getty ]; then
 	# busybox
 	GETTY=getty
 elif [ -x /sbin/agetty -o -x /bin/agetty ]; then
 	# util-linux
 	GETTY=agetty
 fi
 exec setsid ${GETTY} ${GETTY_ARGS} -nl /usr/bin/ly "${TTY}" "${BAUD_RATE}" "${TERM_NAME}"
--- a/res/ly.service
+++ b/res/ly.service
@@ -2,7 +2,6 @@
 Description=TUI display manager
 After=systemd-user-sessions.service plymouth-quit-wait.service
 After=getty@tty2.service
 Conflicts=getty@tty2.service
 [Service]
 Type=idle
--- a/res/wsetup.sh
+++ b/res/wsetup.sh
@@ -40,7 +40,6 @@ case $SHELL in
    ;;
  */fish)
    [ -f /etc/profile ] && . /etc/profile
    [ -f $HOME/.profile ] && . $HOME/.profile
    xsess_tmp=`mktemp /tmp/xsess-env-XXXXXX`
    $SHELL --login -c "/bin/sh -c 'export -p' > $xsess_tmp"
    . $xsess_tmp
@@ -52,4 +51,4 @@ case $SHELL in
    ;;
 esac
-exec "$@"
+exec $@
--- a/res/xsetup.sh
+++ b/res/xsetup.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#! /bin/sh
 # Xsession - run as user
 # Copyright (C) 2016 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
@@ -40,7 +40,6 @@ case $SHELL in
    ;;
  */fish)
    [ -f /etc/profile ] && . /etc/profile
    [ -f $HOME/.profile ] && . $HOME/.profile
    xsess_tmp=`mktemp /tmp/xsess-env-XXXXXX`
    $SHELL --login -c "/bin/sh -c 'export -p' > $xsess_tmp"
    . $xsess_tmp
@@ -83,10 +82,6 @@ if [ -d "$xsessionddir" ]; then
    done
 fi
 if [ -f "$USERXSESSION" ]; then
    . "$USERXSESSION"
 fi
 if [ -d /etc/X11/Xresources ]; then
  for i in /etc/X11/Xresources/*; do
    [ -f $i ] && xrdb -merge $i
@@ -95,7 +90,10 @@ elif [ -f /etc/X11/Xresources ]; then
  xrdb -merge /etc/X11/Xresources
 fi
 [ -f $HOME/.Xresources ] && xrdb -merge $HOME/.Xresources
-[ -f $XDG_CONFIG_HOME/X11/Xresources ] && xrdb -merge $XDG_CONFIG_HOME/X11/Xresources
+
 if [ -f "$USERXSESSION" ]; then
  . "$USERXSESSION"
 fi
 if [ -z "$*" ]; then
    exec xmessage -center -buttons OK:0 -default OK "Sorry, $DESKTOP_SESSION is no valid session."
--- a/selinux/ly.fc
+++ b/selinux/ly.fc
@@ -0,0 +1 @@
 /usr/bin/ly		--	gen_context(system_u:object_r:ly_exec_t,s0)
--- a/selinux/ly.if
+++ b/selinux/ly.if
@@ -0,0 +1,41 @@
 ## <summary>policy for ly</summary>
 ########################################
 ## <summary>
 ##	Execute ly_exec_t in the ly domain.
 ## </summary>
 ## <param name="domain">
 ## <summary>
 ##	Domain allowed to transition.
 ## </summary>
 ## </param>
 #
 interface(`ly_domtrans',`
 	gen_require(`
 		type ly_t, ly_exec_t;
 	')
 	corecmd_search_bin($1)
 	domtrans_pattern($1, ly_exec_t, ly_t)
 ')
 ######################################
 ## <summary>
 ##	Execute ly in the caller domain.
 ## </summary>
 ## <param name="domain">
 ##	<summary>
 ##	Domain allowed access.
 ##	</summary>
 ## </param>
 #
 interface(`ly_exec',`
 	gen_require(`
 		type ly_exec_t;
 	')
 	corecmd_search_bin($1)
 	can_exec($1, ly_exec_t)
 ')
--- a/selinux/ly.te
+++ b/selinux/ly.te
@@ -0,0 +1,32 @@
 policy_module(ly, 1.0.0)
 ########################################
 #
 # Declarations
 #
 type ly_t;
 type ly_exec_t;
 init_daemon_domain(ly_t, ly_exec_t)
 permissive ly_t;
 ########################################
 #
 # ly local policy
 #
 allow ly_t self:capability { setgid setuid };
 allow ly_t self:process { fork signal_perms };
 allow ly_t self:process transition;
 allow ly_t self:fifo_file rw_fifo_file_perms;
 allow ly_t self:unix_stream_socket create_stream_socket_perms;
 domain_use_interactive_fds(ly_t)
 files_read_etc_files(ly_t)
 auth_use_nsswitch(ly_t)
 logging_send_audit_msgs(ly_t)
 miscfiles_read_localization(ly_t)
--- a/src/SharedError.zig
+++ b/src/SharedError.zig
@@ -1,39 +0,0 @@
 const std = @import("std");
 const ErrInt = std.meta.Int(.unsigned, @bitSizeOf(anyerror));
 const ErrorHandler = packed struct {
    has_error: bool = false,
    err_int: ErrInt = 0,
 };
 const SharedError = @This();
 data: []align(std.mem.page_size) u8,
 pub fn init() !SharedError {
    const data = try std.posix.mmap(null, @sizeOf(ErrorHandler), std.posix.PROT.READ | std.posix.PROT.WRITE, .{ .TYPE = .SHARED, .ANONYMOUS = true }, -1, 0);
    return .{ .data = data };
 }
 pub fn deinit(self: *SharedError) void {
    std.posix.munmap(self.data);
 }
 pub fn writeError(self: SharedError, err: anyerror) void {
    var buf_stream = std.io.fixedBufferStream(self.data);
    const writer = buf_stream.writer();
    writer.writeStruct(ErrorHandler{ .has_error = true, .err_int = @intFromError(err) }) catch {};
 }
 pub fn readError(self: SharedError) ?anyerror {
    var buf_stream = std.io.fixedBufferStream(self.data);
    const reader = buf_stream.reader();
    const err_handler = try reader.readStruct(ErrorHandler);
    if (err_handler.has_error)
        return @errorFromInt(err_handler.err_int);
    return null;
 }
--- a/src/animations/Doom.zig
+++ b/src/animations/Doom.zig
@@ -1,84 +0,0 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
 const utils = @import("../tui/utils.zig");
 const interop = @import("../interop.zig");
 const termbox = interop.termbox;
 const Doom = @This();
 pub const STEPS = 13;
 pub const FIRE = [_]termbox.tb_cell{
    utils.initCell(' ', 9, 0),
    utils.initCell(0x2591, 2, 0), // Red
    utils.initCell(0x2592, 2, 0), // Red
    utils.initCell(0x2593, 2, 0), // Red
    utils.initCell(0x2588, 2, 0), // Red
    utils.initCell(0x2591, 4, 2), // Yellow
    utils.initCell(0x2592, 4, 2), // Yellow
    utils.initCell(0x2593, 4, 2), // Yellow
    utils.initCell(0x2588, 4, 2), // Yellow
    utils.initCell(0x2591, 8, 4), // White
    utils.initCell(0x2592, 8, 4), // White
    utils.initCell(0x2593, 8, 4), // White
    utils.initCell(0x2588, 8, 4), // White
 };
 allocator: Allocator,
 terminal_buffer: *TerminalBuffer,
 buffer: []u8,
 pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer) !Doom {
    const buffer = try allocator.alloc(u8, terminal_buffer.width * terminal_buffer.height);
    initBuffer(buffer, terminal_buffer.width);
    return .{
        .allocator = allocator,
        .terminal_buffer = terminal_buffer,
        .buffer = buffer,
    };
 }
 pub fn deinit(self: Doom) void {
    self.allocator.free(self.buffer);
 }
 pub fn realloc(self: *Doom) !void {
    const buffer = try self.allocator.realloc(self.buffer, self.terminal_buffer.width * self.terminal_buffer.height);
    initBuffer(buffer, self.terminal_buffer.width);
    self.buffer = buffer;
 }
 pub fn draw(self: Doom) void {
    for (0..self.terminal_buffer.width) |x| {
        for (1..self.terminal_buffer.height) |y| {
            const source = y * self.terminal_buffer.width + x;
            const random = (self.terminal_buffer.random.int(u16) % 7) & 3;
            var dest = (source - @min(source, random)) + 1;
            if (self.terminal_buffer.width > dest) dest = 0 else dest -= self.terminal_buffer.width;
            const buffer_source = self.buffer[source];
            const buffer_dest_offset = random & 1;
            if (buffer_source < buffer_dest_offset) continue;
            var buffer_dest = buffer_source - buffer_dest_offset;
            if (buffer_dest > 12) buffer_dest = 0;
            self.buffer[dest] = @intCast(buffer_dest);
            self.terminal_buffer.buffer[dest] = FIRE[buffer_dest];
            self.terminal_buffer.buffer[source] = FIRE[buffer_source];
        }
    }
 }
 fn initBuffer(buffer: []u8, width: u64) void {
    const length = buffer.len - width;
    const slice_start = buffer[0..length];
    const slice_end = buffer[length..];
    @memset(slice_start, 0);
    @memset(slice_end, STEPS - 1);
 }
--- a/src/animations/Matrix.zig
+++ b/src/animations/Matrix.zig
@@ -1,181 +0,0 @@
 const std = @import("std");
 const Allocator = std.mem.Allocator;
 const Random = std.rand.Random;
 const TerminalBuffer = @import("../tui/TerminalBuffer.zig");
 const interop = @import("../interop.zig");
 const termbox = interop.termbox;
 pub const FRAME_DELAY: u64 = 8;
 // Allowed codepoints
 pub const MIN_CODEPOINT: isize = 33;
 pub const MAX_CODEPOINT: isize = 123 - MIN_CODEPOINT;
 // Characters change mid-scroll
 pub const MID_SCROLL_CHANGE = true;
 const Matrix = @This();
 pub const Dot = struct {
    value: isize,
    is_head: bool,
 };
 pub const Line = struct {
    space: isize,
    length: isize,
    update: isize,
 };
 allocator: Allocator,
 terminal_buffer: *TerminalBuffer,
 dots: []Dot,
 lines: []Line,
 frame: u64,
 count: u64,
 pub fn init(allocator: Allocator, terminal_buffer: *TerminalBuffer) !Matrix {
    const dots = try allocator.alloc(Dot, terminal_buffer.width * (terminal_buffer.height + 1));
    const lines = try allocator.alloc(Line, terminal_buffer.width);
    initBuffers(dots, lines, terminal_buffer.width, terminal_buffer.height, terminal_buffer.random);
    return .{
        .allocator = allocator,
        .terminal_buffer = terminal_buffer,
        .dots = dots,
        .lines = lines,
        .frame = 3,
        .count = 0,
    };
 }
 pub fn deinit(self: Matrix) void {
    self.allocator.free(self.dots);
    self.allocator.free(self.lines);
 }
 pub fn realloc(self: *Matrix) !void {
    const dots = try self.allocator.realloc(self.dots, self.terminal_buffer.width * (self.terminal_buffer.height + 1));
    const lines = try self.allocator.realloc(self.lines, self.terminal_buffer.width);
    initBuffers(dots, lines, self.terminal_buffer.width, self.terminal_buffer.height, self.terminal_buffer.random);
    self.dots = dots;
    self.lines = lines;
 }
 pub fn draw(self: *Matrix) void {
    const buf_height = self.terminal_buffer.height;
    const buf_width = self.terminal_buffer.width;
    self.count += 1;
    if (self.count > FRAME_DELAY) {
        self.frame += 1;
        if (self.frame > 4) self.frame = 1;
        self.count = 0;
        var x: u64 = 0;
        while (x < self.terminal_buffer.width) : (x += 2) {
            var tail: u64 = 0;
            var line = &self.lines[x];
            if (self.frame <= line.update) continue;
            if (self.dots[x].value == -1 and self.dots[self.terminal_buffer.width + x].value == ' ') {
                if (line.space > 0) {
                    line.space -= 1;
                } else {
                    const randint = self.terminal_buffer.random.int(i16);
                    const h: isize = @intCast(self.terminal_buffer.height);
                    line.length = @mod(randint, h - 3) + 3;
                    self.dots[x].value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                    line.space = @mod(randint, h + 1);
                }
            }
            var y: u64 = 0;
            var first_col = true;
            var seg_len: u64 = 0;
            height_it: while (y <= buf_height) : (y += 1) {
                var dot = &self.dots[buf_width * y + x];
                // Skip over spaces
                while (y <= buf_height and (dot.value == ' ' or dot.value == -1)) {
                    y += 1;
                    if (y > buf_height) break :height_it;
                    dot = &self.dots[buf_width * y + x];
                }
                // Find the head of this column
                tail = y;
                seg_len = 0;
                while (y <= buf_height and dot.value != ' ' and dot.value != -1) {
                    dot.is_head = false;
                    if (MID_SCROLL_CHANGE) {
                        const randint = self.terminal_buffer.random.int(i16);
                        if (@mod(randint, 8) == 0) {
                            dot.value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                        }
                    }
                    y += 1;
                    seg_len += 1;
                    // Head's down offscreen
                    if (y > buf_height) {
                        self.dots[buf_width * tail + x].value = ' ';
                        break :height_it;
                    }
                    dot = &self.dots[buf_width * y + x];
                }
                const randint = self.terminal_buffer.random.int(i16);
                dot.value = @mod(randint, MAX_CODEPOINT) + MIN_CODEPOINT;
                dot.is_head = true;
                if (seg_len > line.length or !first_col) {
                    self.dots[buf_width * tail + x].value = ' ';
                    self.dots[x].value = -1;
                }
                first_col = false;
            }
        }
    }
    var x: u64 = 0;
    while (x < buf_width) : (x += 2) {
        var y: u64 = 1;
        while (y <= self.terminal_buffer.height) : (y += 1) {
            const dot = self.dots[buf_width * y + x];
            var fg: u16 = @intCast(termbox.TB_GREEN);
            if (dot.value == -1 or dot.value == ' ') {
                _ = termbox.tb_set_cell(@intCast(x), @intCast(y - 1), ' ', fg, termbox.TB_DEFAULT);
                continue;
            }
            if (dot.is_head) fg = @intCast(termbox.TB_WHITE | termbox.TB_BOLD);
            _ = termbox.tb_set_cell(@intCast(x), @intCast(y - 1), @intCast(dot.value), fg, termbox.TB_DEFAULT);
        }
    }
 }
 fn initBuffers(dots: []Dot, lines: []Line, width: u64, height: u64, random: Random) void {
    var y: u64 = 0;
    while (y <= height) : (y += 1) {
        var x: u64 = 0;
        while (x < width) : (x += 2) {
            dots[y * width + x].value = -1;
        }
    }
    var x: u64 = 0;
    while (x < width) : (x += 2) {
        var line = lines[x];
        const h: isize = @intCast(height);
        line.space = @mod(random.int(i16), h) + 1;
        line.length = @mod(random.int(i16), h - 3) + 3;
        line.update = @mod(random.int(i16), 3) + 1;
        lines[x] = line;
        dots[width + x].value = ' ';
    }
 }
--- a/src/auth.zig
+++ b/src/auth.zig
@@ -1,520 +0,0 @@
 const std = @import("std");
 const enums = @import("enums.zig");
 const interop = @import("interop.zig");
 const TerminalBuffer = @import("tui/TerminalBuffer.zig");
 const Desktop = @import("tui/components/Desktop.zig");
 const Text = @import("tui/components/Text.zig");
 const Config = @import("config/Config.zig");
 const Allocator = std.mem.Allocator;
 const utmp = interop.utmp;
 const Utmp = utmp.utmp;
 const SharedError = @import("SharedError.zig");
 var xorg_pid: std.posix.pid_t = 0;
 pub fn xorgSignalHandler(i: c_int) callconv(.C) void {
    if (xorg_pid > 0) _ = std.c.kill(xorg_pid, i);
 }
 var child_pid: std.posix.pid_t = 0;
 pub fn sessionSignalHandler(i: c_int) callconv(.C) void {
    if (child_pid > 0) _ = std.c.kill(child_pid, i);
 }
 pub fn authenticate(config: Config, current_environment: Desktop.Environment, login: [:0]const u8, password: [:0]const u8) !void {
    var tty_buffer: [3]u8 = undefined;
    const tty_str = try std.fmt.bufPrintZ(&tty_buffer, "{d}", .{config.tty});
    var pam_tty_buffer: [6]u8 = undefined;
    const pam_tty_str = try std.fmt.bufPrintZ(&pam_tty_buffer, "tty{d}", .{config.tty});
    // Set the XDG environment variables
    setXdgSessionEnv(current_environment.display_server);
    try setXdgEnv(tty_str, current_environment.xdg_session_desktop, current_environment.xdg_desktop_names orelse "");
    // Open the PAM session
    var credentials = [_:null]?[*:0]const u8{ login, password };
    const conv = interop.pam.pam_conv{
        .conv = loginConv,
        .appdata_ptr = @ptrCast(&credentials),
    };
    var handle: ?*interop.pam.pam_handle = undefined;
    var status = interop.pam.pam_start(config.service_name.ptr, null, &conv, &handle);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    defer _ = interop.pam.pam_end(handle, status);
    // Set PAM_TTY as the current TTY. This is required in case it isn't being set by another PAM module
    status = interop.pam.pam_set_item(handle, interop.pam.PAM_TTY, pam_tty_str.ptr);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    // Do the PAM routine
    status = interop.pam.pam_authenticate(handle, 0);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    status = interop.pam.pam_acct_mgmt(handle, 0);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    status = interop.pam.pam_setcred(handle, interop.pam.PAM_ESTABLISH_CRED);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    defer status = interop.pam.pam_setcred(handle, interop.pam.PAM_DELETE_CRED);
    status = interop.pam.pam_open_session(handle, 0);
    if (status != interop.pam.PAM_SUCCESS) return pamDiagnose(status);
    defer status = interop.pam.pam_close_session(handle, 0);
    var pwd: *interop.passwd = undefined;
    {
        defer interop.endpwent();
        // Get password structure from username
        pwd = interop.getpwnam(login.ptr) orelse return error.GetPasswordNameFailed;
    }
    // Set user shell if it hasn't already been set
    if (pwd.pw_shell[0] == 0) {
        interop.setusershell();
        pwd.pw_shell = interop.getusershell();
        interop.endusershell();
    }
    var shared_err = try SharedError.init();
    defer shared_err.deinit();
    child_pid = try std.posix.fork();
    if (child_pid == 0) {
        startSession(config, pwd, handle, current_environment) catch |e| {
            shared_err.writeError(e);
            std.process.exit(1);
        };
        std.process.exit(0);
    }
    var entry = std.mem.zeroes(Utmp);
    {
        // If an error occurs here, we can send SIGTERM to the session
        errdefer cleanup: {
            _ = std.posix.kill(child_pid, std.posix.SIG.TERM) catch break :cleanup;
            _ = std.posix.waitpid(child_pid, 0);
        }
        // If we receive SIGTERM, forward it to child_pid
        const act = std.posix.Sigaction{
            .handler = .{ .handler = &sessionSignalHandler },
            .mask = std.posix.empty_sigset,
            .flags = 0,
        };
        try std.posix.sigaction(std.posix.SIG.TERM, &act, null);
        try addUtmpEntry(&entry, pwd.pw_name, child_pid);
    }
    // Wait for the session to stop
    _ = std.posix.waitpid(child_pid, 0);
    removeUtmpEntry(&entry);
    try resetTerminal(pwd.pw_shell, config.term_reset_cmd);
    if (shared_err.readError()) |err| return err;
 }
 fn startSession(
    config: Config,
    pwd: *interop.passwd,
    handle: ?*interop.pam.pam_handle,
    current_environment: Desktop.Environment,
 ) !void {
    const status = interop.initgroups(pwd.pw_name, pwd.pw_gid);
    if (status != 0) return error.GroupInitializationFailed;
    std.posix.setgid(pwd.pw_gid) catch return error.SetUserGidFailed;
    std.posix.setuid(pwd.pw_uid) catch return error.SetUserUidFailed;
    // Set up the environment
    try initEnv(pwd, config.path);
    // Set the PAM variables
    const pam_env_vars: ?[*:null]?[*:0]u8 = interop.pam.pam_getenvlist(handle);
    if (pam_env_vars == null) return error.GetEnvListFailed;
    const env_list = std.mem.span(pam_env_vars.?);
    for (env_list) |env_var| _ = interop.putenv(env_var.?);
    // Execute what the user requested
    std.posix.chdirZ(pwd.pw_dir) catch return error.ChangeDirectoryFailed;
    try resetTerminal(pwd.pw_shell, config.term_reset_cmd);
    switch (current_environment.display_server) {
        .wayland => try executeWaylandCmd(pwd.pw_shell, config.wayland_cmd, current_environment.cmd),
        .shell => try executeShellCmd(pwd.pw_shell),
        .xinitrc, .x11 => {
            var vt_buf: [5]u8 = undefined;
            const vt = try std.fmt.bufPrint(&vt_buf, "vt{d}", .{config.tty});
            try executeX11Cmd(pwd.pw_shell, pwd.pw_dir, config, current_environment.cmd, vt);
        },
    }
 }
 fn initEnv(pwd: *interop.passwd, path_env: ?[:0]const u8) !void {
    _ = interop.setenv("HOME", pwd.pw_dir, 1);
    _ = interop.setenv("PWD", pwd.pw_dir, 1);
    _ = interop.setenv("SHELL", pwd.pw_shell, 1);
    _ = interop.setenv("USER", pwd.pw_name, 1);
    _ = interop.setenv("LOGNAME", pwd.pw_name, 1);
    if (path_env) |path| {
        const status = interop.setenv("PATH", path, 1);
        if (status != 0) return error.SetPathFailed;
    }
 }
 fn setXdgSessionEnv(display_server: enums.DisplayServer) void {
    _ = interop.setenv("XDG_SESSION_TYPE", switch (display_server) {
        .wayland => "wayland",
        .shell => "tty",
        .xinitrc, .x11 => "x11",
    }, 0);
 }
 fn setXdgEnv(tty_str: [:0]u8, desktop_name: [:0]const u8, xdg_desktop_names: [:0]const u8) !void {
    const uid = interop.getuid();
    var uid_buffer: [10 + @sizeOf(u32) + 1]u8 = undefined;
    const uid_str = try std.fmt.bufPrintZ(&uid_buffer, "/run/user/{d}", .{uid});
    if (!std.mem.eql(u8, xdg_desktop_names, "")) _ = interop.setenv("XDG_CURRENT_DESKTOP", xdg_desktop_names.ptr, 0);
    _ = interop.setenv("XDG_RUNTIME_DIR", uid_str.ptr, 0);
    _ = interop.setenv("XDG_SESSION_CLASS", "user", 0);
    _ = interop.setenv("XDG_SESSION_ID", "1", 0);
    if (!std.mem.eql(u8, desktop_name, "")) _ = interop.setenv("XDG_SESSION_DESKTOP", desktop_name.ptr, 0);
    _ = interop.setenv("XDG_SEAT", "seat0", 0);
    _ = interop.setenv("XDG_VTNR", tty_str.ptr, 0);
 }
 fn loginConv(
    num_msg: c_int,
    msg: ?[*]?*const interop.pam.pam_message,
    resp: ?*?[*]interop.pam.pam_response,
    appdata_ptr: ?*anyopaque,
 ) callconv(.C) c_int {
    const message_count: u32 = @intCast(num_msg);
    const messages = msg.?;
    const allocator = std.heap.c_allocator;
    const response = allocator.alloc(interop.pam.pam_response, message_count) catch return interop.pam.PAM_BUF_ERR;
    // Initialise allocated memory to 0
    // This ensures memory can be freed by pam on success
    @memset(response, std.mem.zeroes(interop.pam.pam_response));
    var username: ?[:0]u8 = null;
    var password: ?[:0]u8 = null;
    var status: c_int = interop.pam.PAM_SUCCESS;
    for (0..message_count) |i| set_credentials: {
        switch (messages[i].?.msg_style) {
            interop.pam.PAM_PROMPT_ECHO_ON => {
                const data: [*][*:0]u8 = @ptrCast(@alignCast(appdata_ptr));
                username = allocator.dupeZ(u8, std.mem.span(data[0])) catch {
                    status = interop.pam.PAM_BUF_ERR;
                    break :set_credentials;
                };
                response[i].resp = username.?.ptr;
            },
            interop.pam.PAM_PROMPT_ECHO_OFF => {
                const data: [*][*:0]u8 = @ptrCast(@alignCast(appdata_ptr));
                password = allocator.dupeZ(u8, std.mem.span(data[1])) catch {
                    status = interop.pam.PAM_BUF_ERR;
                    break :set_credentials;
                };
                response[i].resp = password.?.ptr;
            },
            interop.pam.PAM_ERROR_MSG => {
                status = interop.pam.PAM_CONV_ERR;
                break :set_credentials;
            },
            else => {},
        }
    }
    if (status != interop.pam.PAM_SUCCESS) {
        // Memory is freed by pam otherwise
        allocator.free(response);
        if (username != null) allocator.free(username.?);
        if (password != null) allocator.free(password.?);
    } else {
        resp.?.* = response.ptr;
    }
    return status;
 }
 fn resetTerminal(shell: [*:0]const u8, term_reset_cmd: [:0]const u8) !void {
    const pid = try std.posix.fork();
    if (pid == 0) {
        const args = [_:null]?[*:0]const u8{ shell, "-c", term_reset_cmd };
        std.posix.execveZ(shell, &args, std.c.environ) catch {};
        std.process.exit(1);
    }
    _ = std.posix.waitpid(pid, 0);
 }
 fn getFreeDisplay() !u8 {
    var buf: [15]u8 = undefined;
    var i: u8 = 0;
    while (i < 200) : (i += 1) {
        const xlock = try std.fmt.bufPrint(&buf, "/tmp/.X{d}-lock", .{i});
        std.posix.access(xlock, std.posix.F_OK) catch break;
    }
    return i;
 }
 fn getXPid(display_num: u8) !i32 {
    var buf: [15]u8 = undefined;
    const file_name = try std.fmt.bufPrint(&buf, "/tmp/.X{d}-lock", .{display_num});
    const file = try std.fs.openFileAbsolute(file_name, .{});
    defer file.close();
    var file_buf: [20]u8 = undefined;
    var fbs = std.io.fixedBufferStream(&file_buf);
    _ = try file.reader().streamUntilDelimiter(fbs.writer(), '\n', 20);
    const line = fbs.getWritten();
    return std.fmt.parseInt(i32, std.mem.trim(u8, line, " "), 10);
 }
 fn createXauthFile(pwd: [:0]const u8) ![:0]const u8 {
    var xauth_buf: [100]u8 = undefined;
    var xauth_dir: [:0]const u8 = undefined;
    const xdg_rt_dir = std.posix.getenv("XDG_RUNTIME_DIR");
    var xauth_file: []const u8 = "lyxauth";
    if (xdg_rt_dir == null) {
        const xdg_cfg_home = std.posix.getenv("XDG_CONFIG_HOME");
        var sb: std.c.Stat = undefined;
        if (xdg_cfg_home == null) {
            xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/.config", .{pwd});
            _ = std.c.stat(xauth_dir, &sb);
            const mode = sb.mode & std.posix.S.IFMT;
            if (mode == std.posix.S.IFDIR) {
                xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/ly", .{xauth_dir});
            } else {
                xauth_dir = pwd;
                xauth_file = ".lyxauth";
            }
        } else {
            xauth_dir = try std.fmt.bufPrintZ(&xauth_buf, "{s}/ly", .{xdg_cfg_home.?});
        }
        _ = std.c.stat(xauth_dir, &sb);
        const mode = sb.mode & std.posix.S.IFMT;
        if (mode != std.posix.S.IFDIR) {
            std.posix.mkdir(xauth_dir, 777) catch {
                xauth_dir = pwd;
                xauth_file = ".lyxauth";
            };
        }
    } else {
        xauth_dir = xdg_rt_dir.?;
    }
    // Trim trailing slashes
    var i = xauth_dir.len - 1;
    while (xauth_dir[i] == '/') i -= 1;
    const trimmed_xauth_dir = xauth_dir[0 .. i + 1];
    var buf: [256]u8 = undefined;
    const xauthority: [:0]u8 = try std.fmt.bufPrintZ(&buf, "{s}/{s}", .{ trimmed_xauth_dir, xauth_file });
    const file = try std.fs.createFileAbsoluteZ(xauthority, .{});
    file.close();
    return xauthority;
 }
 pub fn mcookie(shell: [*:0]const u8, cmd: [:0]const u8) ![32]u8 {
    const pipe = try std.posix.pipe();
    defer std.posix.close(pipe[1]);
    const output = std.fs.File{ .handle = pipe[0] };
    defer output.close();
    const pid = try std.posix.fork();
    if (pid == 0) {
        std.posix.close(pipe[0]);
        std.posix.dup2(pipe[1], std.posix.STDOUT_FILENO) catch std.process.exit(1);
        std.posix.close(pipe[1]);
        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd };
        std.posix.execveZ(shell, &args, std.c.environ) catch {};
        std.process.exit(1);
    }
    const result = std.posix.waitpid(pid, 0);
    if (result.status != 0) return error.McookieFailed;
    var buf: [32]u8 = undefined;
    const len = try output.read(&buf);
    if (len != 32) return error.McookieFailed;
    return buf;
 }
 fn xauth(display_name: [:0]u8, shell: [*:0]const u8, pw_dir: [*:0]const u8, xauth_cmd: []const u8, mcookie_cmd: [:0]const u8) !void {
    var pwd_buf: [100]u8 = undefined;
    const pwd = try std.fmt.bufPrintZ(&pwd_buf, "{s}", .{pw_dir});
    const xauthority = try createXauthFile(pwd);
    _ = interop.setenv("XAUTHORITY", xauthority, 1);
    _ = interop.setenv("DISPLAY", display_name, 1);
    const mcookie_output = try mcookie(shell, mcookie_cmd);
    const pid = try std.posix.fork();
    if (pid == 0) {
        var cmd_buffer: [1024]u8 = undefined;
        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} add {s} . {s}", .{ xauth_cmd, display_name, mcookie_output }) catch std.process.exit(1);
        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
        std.posix.execveZ(shell, &args, std.c.environ) catch {};
        std.process.exit(1);
    }
    const status = std.posix.waitpid(pid, 0);
    if (status.status != 0) return error.XauthFailed;
 }
 fn executeShellCmd(shell: [*:0]const u8) !void {
    const args = [_:null]?[*:0]const u8{shell};
    return std.posix.execveZ(shell, &args, std.c.environ);
 }
 fn executeWaylandCmd(shell: [*:0]const u8, wayland_cmd: []const u8, desktop_cmd: []const u8) !void {
    var cmd_buffer: [1024]u8 = undefined;
    const cmd_str = try std.fmt.bufPrintZ(&cmd_buffer, "{s} {s}", .{ wayland_cmd, desktop_cmd });
    const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
    return std.posix.execveZ(shell, &args, std.c.environ);
 }
 fn executeX11Cmd(shell: [*:0]const u8, pw_dir: [*:0]const u8, config: Config, desktop_cmd: []const u8, vt: []const u8) !void {
    const display_num = try getFreeDisplay();
    var buf: [5]u8 = undefined;
    const display_name = try std.fmt.bufPrintZ(&buf, ":{d}", .{display_num});
    try xauth(display_name, shell, pw_dir, config.xauth_cmd, config.mcookie_cmd);
    const pid = try std.posix.fork();
    if (pid == 0) {
        var cmd_buffer: [1024]u8 = undefined;
        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s} {s}", .{ config.x_cmd, display_name, vt }) catch std.process.exit(1);
        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
        std.posix.execveZ(shell, &args, std.c.environ) catch {};
        std.process.exit(1);
    }
    var ok: c_int = undefined;
    var xcb: ?*interop.xcb.xcb_connection_t = null;
    while (ok != 0) {
        xcb = interop.xcb.xcb_connect(null, null);
        ok = interop.xcb.xcb_connection_has_error(xcb);
        std.posix.kill(pid, 0) catch |e| {
            if (e == error.ProcessNotFound and ok != 0) return error.XcbConnectionFailed;
        };
    }
    // X Server detaches from the process.
    // PID can be fetched from /tmp/X{d}.lock
    const x_pid = try getXPid(display_num);
    xorg_pid = try std.posix.fork();
    if (xorg_pid == 0) {
        var cmd_buffer: [1024]u8 = undefined;
        const cmd_str = std.fmt.bufPrintZ(&cmd_buffer, "{s} {s}", .{ config.x_cmd_setup, desktop_cmd }) catch std.process.exit(1);
        const args = [_:null]?[*:0]const u8{ shell, "-c", cmd_str };
        std.posix.execveZ(shell, &args, std.c.environ) catch {};
        std.process.exit(1);
    }
    // If we receive SIGTERM, clean up by killing the xorg_pid process
    const act = std.posix.Sigaction{
        .handler = .{ .handler = &xorgSignalHandler },
        .mask = std.posix.empty_sigset,
        .flags = 0,
    };
    try std.posix.sigaction(std.posix.SIG.TERM, &act, null);
    _ = std.posix.waitpid(xorg_pid, 0);
    interop.xcb.xcb_disconnect(xcb);
    std.posix.kill(x_pid, 0) catch return;
    std.posix.kill(x_pid, std.posix.SIG.TERM) catch {};
    var status: c_int = 0;
    _ = std.c.waitpid(x_pid, &status, 0);
 }
 fn addUtmpEntry(entry: *Utmp, username: [*:0]const u8, pid: c_int) !void {
    entry.ut_type = utmp.USER_PROCESS;
    entry.ut_pid = pid;
    var buf: [4096]u8 = undefined;
    const ttyname = try std.os.getFdPath(std.posix.STDIN_FILENO, &buf);
    var ttyname_buf: [32]u8 = undefined;
    _ = try std.fmt.bufPrintZ(&ttyname_buf, "{s}", .{ttyname["/dev/".len..]});
    entry.ut_line = ttyname_buf;
    entry.ut_id = ttyname_buf["tty".len..7].*;
    var username_buf: [32]u8 = undefined;
    _ = try std.fmt.bufPrintZ(&username_buf, "{s}", .{username});
    entry.ut_user = username_buf;
    var host: [256]u8 = undefined;
    host[0] = 0;
    entry.ut_host = host;
    var tv: std.c.timeval = undefined;
    _ = std.c.gettimeofday(&tv, null);
    entry.ut_tv = .{
        .tv_sec = @intCast(tv.tv_sec),
        .tv_usec = @intCast(tv.tv_usec),
    };
    entry.ut_addr_v6[0] = 0;
    utmp.setutent();
    _ = utmp.pututline(entry);
    utmp.endutent();
 }
 fn removeUtmpEntry(entry: *Utmp) void {
    entry.ut_type = utmp.DEAD_PROCESS;
    entry.ut_line[0] = 0;
    entry.ut_user[0] = 0;
    utmp.setutent();
    _ = utmp.pututline(entry);
    utmp.endutent();
 }
 fn pamDiagnose(status: c_int) anyerror {
    return switch (status) {
        interop.pam.PAM_ACCT_EXPIRED => return error.PamAccountExpired,
        interop.pam.PAM_AUTH_ERR => return error.PamAuthError,
        interop.pam.PAM_AUTHINFO_UNAVAIL => return error.PamAuthInfoUnavailable,
        interop.pam.PAM_BUF_ERR => return error.PamBufferError,
        interop.pam.PAM_CRED_ERR => return error.PamCredentialsError,
        interop.pam.PAM_CRED_EXPIRED => return error.PamCredentialsExpired,
        interop.pam.PAM_CRED_INSUFFICIENT => return error.PamCredentialsInsufficient,
        interop.pam.PAM_CRED_UNAVAIL => return error.PamCredentialsUnavailable,
        interop.pam.PAM_MAXTRIES => return error.PamMaximumTries,
        interop.pam.PAM_NEW_AUTHTOK_REQD => return error.PamNewAuthTokenRequired,
        interop.pam.PAM_PERM_DENIED => return error.PamPermissionDenied,
        interop.pam.PAM_SESSION_ERR => return error.PamSessionError,
        interop.pam.PAM_SYSTEM_ERR => return error.PamSystemError,
        interop.pam.PAM_USER_UNKNOWN => return error.PamUserUnknown,
        else => return error.PamAbort,
    };
 }
--- a/src/bigclock.zig
+++ b/src/bigclock.zig
@@ -1,140 +0,0 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const interop = @import("interop.zig");
 const utils = @import("tui/utils.zig");
 const termbox = interop.termbox;
 const X: u32 = if (builtin.os.tag == .linux or builtin.os.tag.isBSD()) 0x2593 else '#';
 const O: u32 = 0;
 pub const WIDTH = 5;
 pub const HEIGHT = 5;
 pub const SIZE = WIDTH * HEIGHT;
 // zig fmt: off
 const ZERO = [_]u21{
    X,X,X,X,X,
    X,X,O,X,X,
    X,X,O,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
 };
 const ONE = [_]u21{
    O,O,O,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
 };
 const TWO = [_]u21{
    X,X,X,X,X,
    O,O,O,X,X,
    X,X,X,X,X,
    X,X,O,O,O,
    X,X,X,X,X,
 };
 const THREE = [_]u21{
    X,X,X,X,X,
    O,O,O,X,X,
    X,X,X,X,X,
    O,O,O,X,X,
    X,X,X,X,X,
 };
 const FOUR = [_]u21{
    X,X,O,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
 };
 const FIVE = [_]u21{
    X,X,X,X,X,
    X,X,O,O,O,
    X,X,X,X,X,
    O,O,O,X,X,
    X,X,X,X,X,
 };
 const SIX = [_]u21{
    X,X,X,X,X,
    X,X,O,O,O,
    X,X,X,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
 };
 const SEVEN = [_]u21{
    X,X,X,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
    O,O,O,X,X,
 };
 const EIGHT = [_]u21{
    X,X,X,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
 };
 const NINE = [_]u21{
    X,X,X,X,X,
    X,X,O,X,X,
    X,X,X,X,X,
    O,O,O,X,X,
    X,X,X,X,X,
 };
 const S = [_]u21{
    O,O,O,O,O,
    O,O,X,O,O,
    O,O,O,O,O,
    O,O,X,O,O,
    O,O,O,O,O,
 };
 const E = [_]u21{
    O,O,O,O,O,
    O,O,O,O,O,
    O,O,O,O,O,
    O,O,O,O,O,
    O,O,O,O,O,
 };
 // zig fmt: on
 pub fn clockCell(animate: bool, char: u8, fg: u8, bg: u8) [SIZE]termbox.tb_cell {
    var cells: [SIZE]termbox.tb_cell = undefined;
    var tv: std.c.timeval = undefined;
    _ = std.c.gettimeofday(&tv, null);
    const clock_chars = toBigNumber(if (animate and char == ':' and @divTrunc(tv.tv_usec, 500000) != 0) ' ' else char);
    for (0..cells.len) |i| cells[i] = utils.initCell(clock_chars[i], fg, bg);
    return cells;
 }
 pub fn alphaBlit(buffer: [*]termbox.tb_cell, x: u64, y: u64, tb_width: u64, tb_height: u64, cells: [SIZE]termbox.tb_cell) void {
    if (x + WIDTH >= tb_width or y + HEIGHT >= tb_height) return;
    for (0..HEIGHT) |yy| {
        for (0..WIDTH) |xx| {
            const cell = cells[yy * WIDTH + xx];
            if (cell.ch != 0) buffer[(y + yy) * tb_width + (x + xx)] = cell;
        }
    }
 }
 fn toBigNumber(char: u8) []const u21 {
    return switch (char) {
        '0' => &ZERO,
        '1' => &ONE,
        '2' => &TWO,
        '3' => &THREE,
        '4' => &FOUR,
        '5' => &FIVE,
        '6' => &SIX,
        '7' => &SEVEN,
        '8' => &EIGHT,
        '9' => &NINE,
        ':' => &S,
        else => &E,
    };
 }
--- a/src/config.c
+++ b/src/config.c
@@ -0,0 +1,367 @@
 #include "configator.h"
 #include "config.h"
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
 #ifndef DEBUG
 	#define INI_LANG DATADIR "/lang/%s.ini"
 	#define INI_CONFIG "/etc/ly/config.ini"
 #else
 	#define INI_LANG "../res/lang/%s.ini"
 	#define INI_CONFIG "../res/config.ini"
 #endif
 static void lang_handle(void* data, char** pars, const int pars_count)
 {
 	if (*((char**)data) != NULL)
 	{
 		free (*((char**)data));
 	}
 	*((char**)data) = strdup(*pars);
 }
 static void config_handle_u8(void* data, char** pars, const int pars_count)
 {
 	if (strcmp(*pars, "") == 0)
 	{
 		*((u8*)data) = 0;
 	}
 	else
 	{
 		*((u8*)data) = atoi(*pars);
 	}
 }
 static void config_handle_u16(void* data, char** pars, const int pars_count)
 {
 	if (strcmp(*pars, "") == 0)
 	{
 		*((u16*)data) = 0;
 	}
 	else
 	{
 		*((u16*)data) = atoi(*pars);
 	}
 }
 void config_handle_str(void* data, char** pars, const int pars_count)
 {
 	if (*((char**)data) != NULL)
 	{
 		free(*((char**)data));
 	}
 	*((char**)data) = strdup(*pars);
 }
 static void config_handle_char(void* data, char** pars, const int pars_count)
 {
 	*((char*)data) = **pars;
 }
 static void config_handle_bool(void* data, char** pars, const int pars_count)
 {
 	*((bool*)data) = (strcmp("true", *pars) == 0);
 }
 void lang_load()
 {
 	// must be alphabetically sorted
 	struct configator_param map_no_section[] =
 	{
 		{"capslock", &lang.capslock, lang_handle},
 		{"err_alloc", &lang.err_alloc, lang_handle},
 		{"err_bounds", &lang.err_bounds, lang_handle},
 		{"err_chdir", &lang.err_chdir, lang_handle},
 		{"err_console_dev", &lang.err_console_dev, lang_handle},
 		{"err_dgn_oob", &lang.err_dgn_oob, lang_handle},
 		{"err_domain", &lang.err_domain, lang_handle},
 		{"err_hostname", &lang.err_hostname, lang_handle},
 		{"err_mlock", &lang.err_mlock, lang_handle},
 		{"err_null", &lang.err_null, lang_handle},
 		{"err_pam", &lang.err_pam, lang_handle},
 		{"err_pam_abort", &lang.err_pam_abort, lang_handle},
 		{"err_pam_acct_expired", &lang.err_pam_acct_expired, lang_handle},
 		{"err_pam_auth", &lang.err_pam_auth, lang_handle},
 		{"err_pam_authinfo_unavail", &lang.err_pam_authinfo_unavail, lang_handle},
 		{"err_pam_authok_reqd", &lang.err_pam_authok_reqd, lang_handle},
 		{"err_pam_buf", &lang.err_pam_buf, lang_handle},
 		{"err_pam_cred_err", &lang.err_pam_cred_err, lang_handle},
 		{"err_pam_cred_expired", &lang.err_pam_cred_expired, lang_handle},
 		{"err_pam_cred_insufficient", &lang.err_pam_cred_insufficient, lang_handle},
 		{"err_pam_cred_unavail", &lang.err_pam_cred_unavail, lang_handle},
 		{"err_pam_maxtries", &lang.err_pam_maxtries, lang_handle},
 		{"err_pam_perm_denied", &lang.err_pam_perm_denied, lang_handle},
 		{"err_pam_session", &lang.err_pam_session, lang_handle},
 		{"err_pam_sys", &lang.err_pam_sys, lang_handle},
 		{"err_pam_user_unknown", &lang.err_pam_user_unknown, lang_handle},
 		{"err_path", &lang.err_path, lang_handle},
 		{"err_perm_dir", &lang.err_perm_dir, lang_handle},
 		{"err_perm_group", &lang.err_perm_group, lang_handle},
 		{"err_perm_user", &lang.err_perm_user, lang_handle},
 		{"err_pwnam", &lang.err_pwnam, lang_handle},
 		{"err_user_gid", &lang.err_user_gid, lang_handle},
 		{"err_user_init", &lang.err_user_init, lang_handle},
 		{"err_user_uid", &lang.err_user_uid, lang_handle},
 		{"err_xsessions_dir", &lang.err_xsessions_dir, lang_handle},
 		{"err_xsessions_open", &lang.err_xsessions_open, lang_handle},
 		{"f1", &lang.f1, lang_handle},
 		{"f2", &lang.f2, lang_handle},
 		{"login", &lang.login, lang_handle},
 		{"logout", &lang.logout, lang_handle},
 		{"numlock", &lang.numlock, lang_handle},
 		{"password", &lang.password, lang_handle},
 		{"shell", &lang.shell, lang_handle},
 		{"wayland", &lang.wayland, lang_handle},
 		{"xinitrc", &lang.xinitrc, lang_handle},
 	};
 	uint16_t map_len[] = {45};
 	struct configator_param* map[] =
 	{
 		map_no_section,
 	};
 	uint16_t sections_len = 0;
 	struct configator_param* sections = NULL;
 	struct configator lang;
 	lang.map = map;
 	lang.map_len = map_len;
 	lang.sections = sections;
 	lang.sections_len = sections_len;
 	char file[256];
 	snprintf(file, 256, INI_LANG, config.lang);
 	if (access(file, F_OK) != -1)
 	{
 		configator(&lang, file);
 	}
 }
 void config_load(const char *cfg_path)
 {
 	if (cfg_path == NULL)
 	{
 		cfg_path = INI_CONFIG;
 	}
 	// must be alphabetically sorted
 	struct configator_param map_no_section[] =
 	{
 		{"animate", &config.animate, config_handle_bool},
 		{"animation", &config.animation, config_handle_u8},
 		{"asterisk", &config.asterisk, config_handle_char},
 		{"bg", &config.bg, config_handle_u8},
 		{"blank_box", &config.blank_box, config_handle_bool},
 		{"blank_password", &config.blank_password, config_handle_bool},
 		{"console_dev", &config.console_dev, config_handle_str},
 		{"default_input", &config.default_input, config_handle_u8},
 		{"fg", &config.fg, config_handle_u8},
 		{"hide_borders", &config.hide_borders, config_handle_bool},
 		{"input_len", &config.input_len, config_handle_u8},
 		{"lang", &config.lang, config_handle_str},
 		{"load", &config.load, config_handle_bool},
 		{"margin_box_h", &config.margin_box_h, config_handle_u8},
 		{"margin_box_v", &config.margin_box_v, config_handle_u8},
 		{"max_desktop_len", &config.max_desktop_len, config_handle_u8},
 		{"max_login_len", &config.max_login_len, config_handle_u8},
 		{"max_password_len", &config.max_password_len, config_handle_u8},
 		{"mcookie_cmd", &config.mcookie_cmd, config_handle_str},
 		{"min_refresh_delta", &config.min_refresh_delta, config_handle_u16},
 		{"path", &config.path, config_handle_str},
 		{"restart_cmd", &config.restart_cmd, config_handle_str},
 		{"save", &config.save, config_handle_bool},
 		{"save_file", &config.save_file, config_handle_str},
 		{"service_name", &config.service_name, config_handle_str},
 		{"shutdown_cmd", &config.shutdown_cmd, config_handle_str},
 		{"term_reset_cmd", &config.term_reset_cmd, config_handle_str},
 		{"tty", &config.tty, config_handle_u8},
 		{"wayland_cmd", &config.wayland_cmd, config_handle_str},
 		{"wayland_specifier", &config.wayland_specifier, config_handle_bool},
 		{"waylandsessions", &config.waylandsessions, config_handle_str},
 		{"x_cmd", &config.x_cmd, config_handle_str},
 		{"x_cmd_setup", &config.x_cmd_setup, config_handle_str},
 		{"xauth_cmd", &config.xauth_cmd, config_handle_str},
 		{"xsessions", &config.xsessions, config_handle_str},
 	};
 	uint16_t map_len[] = {34};
 	struct configator_param* map[] =
 	{
 		map_no_section,
 	};
 	uint16_t sections_len = 0;
 	struct configator_param* sections = NULL;
 	struct configator config;
 	config.map = map;
 	config.map_len = map_len;
 	config.sections = sections;
 	config.sections_len = sections_len;
 	configator(&config, (char *) cfg_path);
 }
 void lang_defaults()
 {
 	lang.capslock = strdup("capslock");
 	lang.err_alloc = strdup("failed memory allocation");
 	lang.err_bounds = strdup("out-of-bounds index");
 	lang.err_chdir = strdup("failed to open home folder");
 	lang.err_console_dev = strdup("failed to access console");
 	lang.err_dgn_oob = strdup("log message");
 	lang.err_domain = strdup("invalid domain");
 	lang.err_hostname = strdup("failed to get hostname");
 	lang.err_mlock = strdup("failed to lock password memory");
 	lang.err_null = strdup("null pointer");
 	lang.err_pam = strdup("pam transaction failed");
 	lang.err_pam_abort = strdup("pam transaction aborted");
 	lang.err_pam_acct_expired = strdup("account expired");
 	lang.err_pam_auth = strdup("authentication error");
 	lang.err_pam_authinfo_unavail = strdup("failed to get user info");
 	lang.err_pam_authok_reqd = strdup("token expired");
 	lang.err_pam_buf = strdup("memory buffer error");
 	lang.err_pam_cred_err = strdup("failed to set credentials");
 	lang.err_pam_cred_expired = strdup("credentials expired");
 	lang.err_pam_cred_insufficient = strdup("insufficient credentials");
 	lang.err_pam_cred_unavail = strdup("failed to get credentials");
 	lang.err_pam_maxtries = strdup("reached maximum tries limit");
 	lang.err_pam_perm_denied = strdup("permission denied");
 	lang.err_pam_session = strdup("session error");
 	lang.err_pam_sys = strdup("system error");
 	lang.err_pam_user_unknown = strdup("unknown user");
 	lang.err_path = strdup("failed to set path");
 	lang.err_perm_dir = strdup("failed to change current directory");
 	lang.err_perm_group = strdup("failed to downgrade group permissions");
 	lang.err_perm_user = strdup("failed to downgrade user permissions");
 	lang.err_pwnam = strdup("failed to get user info");
 	lang.err_user_gid = strdup("failed to set user GID");
 	lang.err_user_init = strdup("failed to initialize user");
 	lang.err_user_uid = strdup("failed to set user UID");
 	lang.err_xsessions_dir = strdup("failed to find sessions folder");
 	lang.err_xsessions_open = strdup("failed to open sessions folder");
 	lang.f1 = strdup("F1 shutdown");
 	lang.f2 = strdup("F2 reboot");
 	lang.login = strdup("login:");
 	lang.logout = strdup("logged out");
 	lang.numlock = strdup("numlock");
 	lang.password = strdup("password:");
 	lang.shell = strdup("shell");
 	lang.wayland = strdup("wayland");
 	lang.xinitrc = strdup("xinitrc");
 }
 void config_defaults()
 {
 	config.animate = false;
 	config.animation = 0;
 	config.asterisk = '*';
 	config.bg = 0;
 	config.blank_box = true;
 	config.blank_password = false;
 	config.console_dev = strdup("/dev/console");
 	config.default_input = PASSWORD_INPUT;
 	config.fg = 9;
 	config.hide_borders = false;
 	config.input_len = 34;
 	config.lang = strdup("en");
 	config.load = true;
 	config.margin_box_h = 2;
 	config.margin_box_v = 1;
 	config.max_desktop_len = 100;
 	config.max_login_len = 255;
 	config.max_password_len = 255;
 	config.mcookie_cmd = strdup("/usr/bin/mcookie");
 	config.min_refresh_delta = 5;
 	config.path = strdup("/sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/usr/sbin");
 	config.restart_cmd = strdup("/sbin/shutdown -r now");
 	config.save = true;
 	config.save_file = strdup("/etc/ly/save");
 	config.service_name = strdup("ly");
 	config.shutdown_cmd = strdup("/sbin/shutdown -a now");
 	config.term_reset_cmd = strdup("/usr/bin/tput reset");
 	config.tty = 2;
 	config.wayland_cmd = strdup(DATADIR "/wsetup.sh");
 	config.wayland_specifier = false;
 	config.waylandsessions = strdup("/usr/share/wayland-sessions");
 	config.x_cmd = strdup("/usr/bin/X");
 	config.x_cmd_setup = strdup(DATADIR "/xsetup.sh");
 	config.xauth_cmd = strdup("/usr/bin/xauth");
 	config.xsessions = strdup("/usr/share/xsessions");
 }
 void lang_free()
 {
 	free(lang.capslock);
 	free(lang.err_alloc);
 	free(lang.err_bounds);
 	free(lang.err_chdir);
 	free(lang.err_console_dev);
 	free(lang.err_dgn_oob);
 	free(lang.err_domain);
 	free(lang.err_hostname);
 	free(lang.err_mlock);
 	free(lang.err_null);
 	free(lang.err_pam);
 	free(lang.err_pam_abort);
 	free(lang.err_pam_acct_expired);
 	free(lang.err_pam_auth);
 	free(lang.err_pam_authinfo_unavail);
 	free(lang.err_pam_authok_reqd);
 	free(lang.err_pam_buf);
 	free(lang.err_pam_cred_err);
 	free(lang.err_pam_cred_expired);
 	free(lang.err_pam_cred_insufficient);
 	free(lang.err_pam_cred_unavail);
 	free(lang.err_pam_maxtries);
 	free(lang.err_pam_perm_denied);
 	free(lang.err_pam_session);
 	free(lang.err_pam_sys);
 	free(lang.err_pam_user_unknown);
 	free(lang.err_path);
 	free(lang.err_perm_dir);
 	free(lang.err_perm_group);
 	free(lang.err_perm_user);
 	free(lang.err_pwnam);
 	free(lang.err_user_gid);
 	free(lang.err_user_init);
 	free(lang.err_user_uid);
 	free(lang.err_xsessions_dir);
 	free(lang.err_xsessions_open);
 	free(lang.f1);
 	free(lang.f2);
 	free(lang.login);
 	free(lang.logout);
 	free(lang.numlock);
 	free(lang.password);
 	free(lang.shell);
 	free(lang.wayland);
 	free(lang.xinitrc);
 }
 void config_free()
 {
 	free(config.console_dev);
 	free(config.lang);
 	free(config.mcookie_cmd);
 	free(config.path);
 	free(config.restart_cmd);
 	free(config.save_file);
 	free(config.service_name);
 	free(config.shutdown_cmd);
 	free(config.term_reset_cmd);
 	free(config.wayland_cmd);
 	free(config.waylandsessions);
 	free(config.x_cmd);
 	free(config.x_cmd_setup);
 	free(config.xauth_cmd);
 	free(config.xsessions);
 }
--- a/src/config.h
+++ b/src/config.h
@@ -0,0 +1,111 @@
 #ifndef H_LY_CONFIG
 #define H_LY_CONFIG
 #include "ctypes.h"
 enum INPUTS {
 	SESSION_SWITCH,
 	LOGIN_INPUT,
 	PASSWORD_INPUT,
 };
 struct lang
 {
 	char* capslock;
 	char* err_alloc;
 	char* err_bounds;
 	char* err_chdir;
 	char* err_console_dev;
 	char* err_dgn_oob;
 	char* err_domain;
 	char* err_hostname;
 	char* err_mlock;
 	char* err_null;
 	char* err_pam;
 	char* err_pam_abort;
 	char* err_pam_acct_expired;
 	char* err_pam_auth;
 	char* err_pam_authinfo_unavail;
 	char* err_pam_authok_reqd;
 	char* err_pam_buf;
 	char* err_pam_cred_err;
 	char* err_pam_cred_expired;
 	char* err_pam_cred_insufficient;
 	char* err_pam_cred_unavail;
 	char* err_pam_maxtries;
 	char* err_pam_perm_denied;
 	char* err_pam_session;
 	char* err_pam_sys;
 	char* err_pam_user_unknown;
 	char* err_path;
 	char* err_perm_dir;
 	char* err_perm_group;
 	char* err_perm_user;
 	char* err_pwnam;
 	char* err_user_gid;
 	char* err_user_init;
 	char* err_user_uid;
 	char* err_xsessions_dir;
 	char* err_xsessions_open;
 	char* f1;
 	char* f2;
 	char* login;
 	char* logout;
 	char* numlock;
 	char* password;
 	char* shell;
 	char* wayland;
 	char* xinitrc;
 };
 struct config
 {
 	bool animate;
 	u8 animation;
 	char asterisk;
 	u8 bg;
 	bool blank_box;
 	bool blank_password;
 	char* console_dev;
 	u8 default_input;
 	u8 fg;
 	bool hide_borders;
 	u8 input_len;
 	char* lang;
 	bool load;
 	u8 margin_box_h;
 	u8 margin_box_v;
 	u8 max_desktop_len;
 	u8 max_login_len;
 	u8 max_password_len;
 	char* mcookie_cmd;
 	u16 min_refresh_delta;
 	char* path;
 	char* restart_cmd;
 	bool save;
 	char* save_file;
 	char* service_name;
 	char* shutdown_cmd;
 	char* term_reset_cmd;
 	u8 tty;
 	char* wayland_cmd;
 	bool wayland_specifier;
 	char* waylandsessions;
 	char* x_cmd;
 	char* x_cmd_setup;
 	char* xauth_cmd;
 	char* xsessions;
 };
 extern struct lang lang;
 extern struct config config;
 void config_handle_str(void* data, char** pars, const int pars_count);
 void lang_load();
 void config_load(const char *cfg_path);
 void lang_defaults();
 void config_defaults();
 void lang_free();
 void config_free();
 #endif
--- a/src/config/Config.zig
+++ b/src/config/Config.zig
@@ -1,53 +0,0 @@
 const build_options = @import("build_options");
 const enums = @import("../enums.zig");
 const Animation = enums.Animation;
 const Input = enums.Input;
 animation: Animation = .none,
 asterisk: u8 = '*',
 bg: u8 = 0,
 bigclock: bool = false,
 blank_box: bool = true,
 border_fg: u8 = 8,
 box_title: ?[]const u8 = null,
 clear_password: bool = false,
 clock: ?[:0]const u8 = null,
 console_dev: [:0]const u8 = "/dev/console",
 default_input: Input = .login,
 fg: u8 = 8,
 hide_borders: bool = false,
 hide_key_hints: bool = false,
 initial_info_text: ?[]const u8 = null,
 input_len: u8 = 34,
 lang: []const u8 = "en",
 load: bool = true,
 margin_box_h: u8 = 2,
 margin_box_v: u8 = 1,
 max_desktop_len: u8 = 100,
 max_login_len: u8 = 255,
 max_password_len: u8 = 255,
 mcookie_cmd: [:0]const u8 = "/usr/bin/mcookie",
 min_refresh_delta: u16 = 5,
 numlock: bool = false,
 path: ?[:0]const u8 = "/sbin:/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin",
 restart_cmd: []const u8 = "/sbin/shutdown -r now",
 restart_key: []const u8 = "F2",
 save: bool = true,
 save_file: []const u8 = "/etc/ly/save",
 service_name: [:0]const u8 = "ly",
 shutdown_cmd: []const u8 = "/sbin/shutdown -a now",
 shutdown_key: []const u8 = "F1",
 sleep_cmd: ?[]const u8 = null,
 sleep_key: []const u8 = "F3",
 term_reset_cmd: [:0]const u8 = "/usr/bin/tput reset",
 term_restore_cursor_cmd: []const u8 = "/usr/bin/tput cnorm",
 tty: u8 = 2,
 vi_mode: bool = false,
 wayland_cmd: []const u8 = build_options.data_directory ++ "/wsetup.sh",
 waylandsessions: []const u8 = "/usr/share/wayland-sessions",
 x_cmd: []const u8 = "/usr/bin/X",
 xinitrc: ?[]const u8 = "~/.xinitrc",
 x_cmd_setup: []const u8 = build_options.data_directory ++ "/xsetup.sh",
 xauth_cmd: []const u8 = "/usr/bin/xauth",
 xsessions: []const u8 = "/usr/share/xsessions",
--- a/src/config/Lang.zig
+++ b/src/config/Lang.zig
@@ -1,56 +0,0 @@
 authenticating: []const u8 = "authenticating...",
 capslock: []const u8 = "capslock",
 err_alloc: []const u8 = "failed memory allocation",
 err_bounds: []const u8 = "out-of-bounds index",
 err_chdir: []const u8 = "failed to open home folder",
 err_console_dev: []const u8 = "failed to access console",
 err_dgn_oob: []const u8 = "log message",
 err_domain: []const u8 = "invalid domain",
 err_envlist: []const u8 = "failed to get envlist",
 err_hostname: []const u8 = "failed to get hostname",
 err_mcookie: []const u8 = "mcookie command failed",
 err_mlock: []const u8 = "failed to lock password memory",
 err_null: []const u8 = "null pointer",
 err_pam: []const u8 = "pam transaction failed",
 err_pam_abort: []const u8 = "pam transaction aborted",
 err_pam_acct_expired: []const u8 = "account expired",
 err_pam_auth: []const u8 = "authentication error",
 err_pam_authinfo_unavail: []const u8 = "failed to get user info",
 err_pam_authok_reqd: []const u8 = "token expired",
 err_pam_buf: []const u8 = "memory buffer error",
 err_pam_cred_err: []const u8 = "failed to set credentials",
 err_pam_cred_expired: []const u8 = "credentials expired",
 err_pam_cred_insufficient: []const u8 = "insufficient credentials",
 err_pam_cred_unavail: []const u8 = "failed to get credentials",
 err_pam_maxtries: []const u8 = "reached maximum tries limit",
 err_pam_perm_denied: []const u8 = "permission denied",
 err_pam_session: []const u8 = "session error",
 err_pam_sys: []const u8 = "system error",
 err_pam_user_unknown: []const u8 = "unknown user",
 err_path: []const u8 = "failed to set path",
 err_perm_dir: []const u8 = "failed to change current directory",
 err_perm_group: []const u8 = "failed to downgrade group permissions",
 err_perm_user: []const u8 = "failed to downgrade user permissions",
 err_pwnam: []const u8 = "failed to get user info",
 err_unknown: []const u8 = "an unknown error occurred",
 err_user_gid: []const u8 = "failed to set user GID",
 err_user_init: []const u8 = "failed to initialize user",
 err_user_uid: []const u8 = "failed to set user UID",
 err_xauth: []const u8 = "xauth command failed",
 err_xcb_conn: []const u8 = "xcb connection failed",
 err_xsessions_dir: []const u8 = "failed to find sessions folder",
 err_xsessions_open: []const u8 = "failed to open sessions folder",
 insert: []const u8 = "insert",
 login: []const u8 = "login:",
 logout: []const u8 = "logged out",
 normal: []const u8 = "normal",
 numlock: []const u8 = "numlock",
 other: []const u8 = "other",
 password: []const u8 = "password:",
 restart: []const u8 = "reboot",
 shell: [:0]const u8 = "shell",
 shutdown: []const u8 = "shutdown",
 sleep: []const u8 = "sleep",
 wayland: []const u8 = "wayland",
 xinitrc: [:0]const u8 = "xinitrc",
 x11: []const u8 = "x11",
--- a/src/config/Save.zig
+++ b/src/config/Save.zig
@@ -1,2 +0,0 @@
 user: ?[]const u8 = null,
 session_index: ?u64 = null,
--- a/src/config/migrator.zig
+++ b/src/config/migrator.zig
@@ -1,42 +0,0 @@
 // The migrator ensures compatibility with <=0.6.0 configuration files
 const std = @import("std");
 const ini = @import("zigini");
 const Save = @import("Save.zig");
 pub fn configFieldHandler(_: std.mem.Allocator, field: ini.IniField) ?ini.IniField {
    var mapped_field = field;
    if (std.mem.eql(u8, field.key, "blank_password")) {
        mapped_field.key = "clear_password";
    }
    return mapped_field;
 }
 pub fn tryMigrateSaveFile(user_buf: *[32]u8, path: []const u8) Save {
    var save = Save{};
    var file = std.fs.openFileAbsolute(path, .{}) catch return save;
    defer file.close();
    const reader = file.reader();
    var user_fbs = std.io.fixedBufferStream(user_buf);
    reader.streamUntilDelimiter(user_fbs.writer(), '\n', 32) catch return save;
    const user = user_fbs.getWritten();
    if (user.len > 0) save.user = user;
    var session_buf: [20]u8 = undefined;
    var session_fbs = std.io.fixedBufferStream(&session_buf);
    reader.streamUntilDelimiter(session_fbs.writer(), '\n', 20) catch {};
    const session_index_str = session_fbs.getWritten();
    var session_index: ?u64 = null;
    if (session_index_str.len > 0) {
        session_index = std.fmt.parseUnsigned(u64, session_index_str, 10) catch return save;
    }
    save.session_index = session_index;
    return save;
 }
--- a/src/dragonfail_error.h
+++ b/src/dragonfail_error.h
@@ -0,0 +1,27 @@
 #ifndef H_DRAGONFAIL_ERROR
 #define H_DRAGONFAIL_ERROR
 enum dgn_error
 {
 	DGN_OK, // do not remove
 	DGN_NULL,
 	DGN_ALLOC,
 	DGN_BOUNDS,
 	DGN_DOMAIN,
 	DGN_MLOCK,
 	DGN_XSESSIONS_DIR,
 	DGN_XSESSIONS_OPEN,
 	DGN_PATH,
 	DGN_CHDIR,
 	DGN_PWNAM,
 	DGN_USER_INIT,
 	DGN_USER_GID,
 	DGN_USER_UID,
 	DGN_PAM,
 	DGN_HOSTNAME,
 	DGN_SIZE, // do not remove
 };
 #endif
--- a/src/draw.c
+++ b/src/draw.c
@@ -0,0 +1,647 @@
 #include "dragonfail.h"
 #include "termbox.h"
 #include "ctypes.h"
 #include "inputs.h"
 #include "utils.h"
 #include "config.h"
 #include "draw.h"
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #if defined(__DragonFly__) || defined(__FreeBSD__)
 	#include <sys/kbio.h>
 #else // linux
 	#include <linux/kd.h>
 #endif
 #define DOOM_STEPS 13
 void draw_init(struct term_buf* buf)
 {
 	buf->width = tb_width();
 	buf->height = tb_height();
 	hostname(&buf->info_line);
 	u16 len_login = strlen(lang.login);
 	u16 len_password = strlen(lang.password);
 	if (len_login > len_password)
 	{
 		buf->labels_max_len = len_login;
 	}
 	else
 	{
 		buf->labels_max_len = len_password;
 	}
 	buf->box_height = 7 + (2 * config.margin_box_v);
 	buf->box_width =
 		(2 * config.margin_box_h)
 		+ (config.input_len + 1)
 		+ buf->labels_max_len;
 #if defined(__linux__)
 	buf->box_chars.left_up = 0x250c;
 	buf->box_chars.left_down = 0x2514;
 	buf->box_chars.right_up = 0x2510;
 	buf->box_chars.right_down = 0x2518;
 	buf->box_chars.top = 0x2500;
 	buf->box_chars.bot = 0x2500;
 	buf->box_chars.left = 0x2502;
 	buf->box_chars.right = 0x2502;
 #else
 	buf->box_chars.left_up = '+';
 	buf->box_chars.left_down = '+';
 	buf->box_chars.right_up = '+';
 	buf->box_chars.right_down= '+';
 	buf->box_chars.top = '-';
 	buf->box_chars.bot = '-';
 	buf->box_chars.left = '|';
 	buf->box_chars.right = '|';
 #endif
 }
 void draw_free(struct term_buf* buf)
 {
 	if (config.animate)
 	{
 		free(buf->tmp_buf);
 	}
 }
 void draw_box(struct term_buf* buf)
 {
 	u16 box_x = (buf->width - buf->box_width) / 2;
 	u16 box_y = (buf->height - buf->box_height) / 2;
 	u16 box_x2 = (buf->width + buf->box_width) / 2;
 	u16 box_y2 = (buf->height + buf->box_height) / 2;
 	buf->box_x = box_x;
 	buf->box_y = box_y;
 	if (!config.hide_borders)
 	{
 		// corners
 		tb_change_cell(
 			box_x - 1,
 			box_y - 1,
 			buf->box_chars.left_up,
 			config.fg,
 			config.bg);
 		tb_change_cell(
 			box_x2,
 			box_y - 1,
 			buf->box_chars.right_up,
 			config.fg,
 			config.bg);
 		tb_change_cell(
 			box_x - 1,
 			box_y2,
 			buf->box_chars.left_down,
 			config.fg,
 			config.bg);
 		tb_change_cell(
 			box_x2,
 			box_y2,
 			buf->box_chars.right_down,
 			config.fg,
 			config.bg);
 		// top and bottom
 		struct tb_cell c1 = {buf->box_chars.top, config.fg, config.bg};
 		struct tb_cell c2 = {buf->box_chars.bot, config.fg, config.bg};
 		for (u8 i = 0; i < buf->box_width; ++i)
 		{
 			tb_put_cell(
 				box_x + i,
 				box_y - 1,
 				&c1);
 			tb_put_cell(
 				box_x + i,
 				box_y2,
 				&c2);
 		}
 		// left and right
 		c1.ch = buf->box_chars.left;
 		c2.ch = buf->box_chars.right;
 		for (u8 i = 0; i < buf->box_height; ++i)
 		{
 			tb_put_cell(
 				box_x - 1,
 				box_y + i,
 				&c1);
 			tb_put_cell(
 				box_x2,
 				box_y + i,
 				&c2);
 		}
 	}
 	if (config.blank_box)
 	{
 		struct tb_cell blank = {' ', config.fg, config.bg};
 		for (u8 i = 0; i < buf->box_height; ++i)
 		{
 			for (u8 k = 0; k < buf->box_width; ++k)
 			{
 				tb_put_cell(
 					box_x + k,
 					box_y + i,
 					&blank);
 			}
 		}
 	}
 }
 struct tb_cell* strn_cell(char* s, u16 len) // throws
 {
 	struct tb_cell* cells = malloc((sizeof (struct tb_cell)) * len);
 	char* s2 = s;
 	u32 c;
 	if (cells != NULL)
 	{
 		for (u16 i = 0; i < len; ++i)
 		{
 			if ((s2 - s) >= len)
 			{
 				break;
 			}
 			s2 += utf8_char_to_unicode(&c, s2);
 			cells[i].ch = c;
 			cells[i].bg = config.bg;
 			cells[i].fg = config.fg;
 		}
 	}
 	else
 	{
 		dgn_throw(DGN_ALLOC);
 	}
 	return cells;
 }
 struct tb_cell* str_cell(char* s) // throws
 {
 	return strn_cell(s, strlen(s));
 }
 void draw_labels(struct term_buf* buf) // throws
 {
 	// login text
 	struct tb_cell* login = str_cell(lang.login);
 	if (dgn_catch())
 	{
 		dgn_reset();
 	}
 	else
 	{
 		tb_blit(
 			buf->box_x + config.margin_box_h,
 			buf->box_y + config.margin_box_v + 4,
 			strlen(lang.login),
 			1,
 			login);
 		free(login);
 	}
 	// password text
 	struct tb_cell* password = str_cell(lang.password);
 	if (dgn_catch())
 	{
 		dgn_reset();
 	}
 	else
 	{
 		tb_blit(
 			buf->box_x + config.margin_box_h,
 			buf->box_y + config.margin_box_v + 6,
 			strlen(lang.password),
 			1,
 			password);
 		free(password);
 	}
 	if (buf->info_line != NULL)
 	{
 		u16 len = strlen(buf->info_line);
 		struct tb_cell* info_cell = str_cell(buf->info_line);
 		if (dgn_catch())
 		{
 			dgn_reset();
 		}
 		else
 		{
 			tb_blit(
 				buf->box_x + ((buf->box_width - len) / 2),
 				buf->box_y + config.margin_box_v,
 				len,
 				1,
 				info_cell);
 			free(info_cell);
 		}
 	}
 }
 void draw_f_commands()
 {
 	struct tb_cell* f1 = str_cell(lang.f1);
 	if (dgn_catch())
 	{
 		dgn_reset();
 	}
 	else
 	{
 		tb_blit(0, 0, strlen(lang.f1), 1, f1);
 		free(f1);
 	}
 	struct tb_cell* f2 = str_cell(lang.f2);
 	if (dgn_catch())
 	{
 		dgn_reset();
 	}
 	else
 	{
 		tb_blit(strlen(lang.f1) + 1, 0, strlen(lang.f2), 1, f2);
 		free(f2);
 	}
 }
 void draw_lock_state(struct term_buf* buf)
 {
 	// get values
 	int fd = open(config.console_dev, O_RDONLY);
 	if (fd < 0)
 	{
 		buf->info_line = lang.err_console_dev;
 		return;
 	}
 	bool numlock_on;
 	bool capslock_on;
 #if defined(__DragonFly__) || defined(__FreeBSD__)
 	int led;
 	ioctl(fd, KDGETLED, &led);
 	numlock_on = led & LED_NUM;
 	capslock_on = led & LED_CAP;
 #else // linux
 	char led;
 	ioctl(fd, KDGKBLED, &led);
 	numlock_on = led & K_NUMLOCK;
 	capslock_on = led & K_CAPSLOCK;
 #endif
 	close(fd);
 	// print text
 	u16 pos_x = buf->width - strlen(lang.numlock);
 	if (numlock_on)
 	{
 		struct tb_cell* numlock = str_cell(lang.numlock);
 		if (dgn_catch())
 		{
 			dgn_reset();
 		}
 		else
 		{
 			tb_blit(pos_x, 0, strlen(lang.numlock), 1, numlock);
 			free(numlock);
 		}
 	}
 	pos_x -= strlen(lang.capslock) + 1;
 	if (capslock_on)
 	{
 		struct tb_cell* capslock = str_cell(lang.capslock);
 		if (dgn_catch())
 		{
 			dgn_reset();
 		}
 		else
 		{
 			tb_blit(pos_x, 0, strlen(lang.capslock), 1, capslock);
 			free(capslock);
 		}
 	}
 }
 void draw_desktop(struct desktop* target)
 {
 	u16 len = strlen(target->list[target->cur]);
 	if (len > (target->visible_len - 3))
 	{
 		len = target->visible_len - 3;
 	}
 	tb_change_cell(
 		target->x,
 		target->y,
 		'<',
 		config.fg,
 		config.bg);
 	tb_change_cell(
 		target->x + target->visible_len - 1,
 		target->y,
 		'>',
 		config.fg,
 		config.bg);
 	for (u16 i = 0; i < len; ++ i)
 	{
 		tb_change_cell(
 			target->x + i + 2,
 			target->y,
 			target->list[target->cur][i],
 			config.fg,
 			config.bg);
 	}
 }
 void draw_input(struct text* input)
 {
 	u16 len = strlen(input->text);
 	u16 visible_len = input->visible_len;
 	if (len > visible_len)
 	{
 		len = visible_len;
 	}
 	struct tb_cell* cells = strn_cell(input->visible_start, len);
 	if (dgn_catch())
 	{
 		dgn_reset();
 	}
 	else
 	{
 		tb_blit(input->x, input->y, len, 1, cells);
 		free(cells);
 		struct tb_cell c1 = {' ', config.fg, config.bg};
 		for (u16 i = input->end - input->visible_start; i < visible_len; ++i)
 		{
 			tb_put_cell(
 				input->x + i,
 				input->y,
 				&c1);
 		}
 	}
 }
 void draw_input_mask(struct text* input)
 {
 	u16 len = strlen(input->text);
 	u16 visible_len = input->visible_len;
 	if (len > visible_len)
 	{
 		len = visible_len;
 	}
 	struct tb_cell c1 = {config.asterisk, config.fg, config.bg};
 	struct tb_cell c2 = {' ', config.fg, config.bg};
 	for (u16 i = 0; i < visible_len; ++i)
 	{
 		if (input->visible_start + i < input->end)
 		{
 			tb_put_cell(
 				input->x + i,
 				input->y,
 				&c1);
 		}
 		else
 		{
 			tb_put_cell(
 				input->x + i,
 				input->y,
 				&c2);
 		}
 	}
 }
 void position_input(
 	struct term_buf* buf,
 	struct desktop* desktop,
 	struct text* login,
 	struct text* password)
 {
 	u16 x = buf->box_x + config.margin_box_h + buf->labels_max_len + 1;
 	i32 len = buf->box_x + buf->box_width - config.margin_box_h - x;
 	if (len < 0)
 	{
 		return;
 	}
 	desktop->x = x;
 	desktop->y = buf->box_y + config.margin_box_v + 2;
 	desktop->visible_len = len;
 	login->x = x;
 	login->y = buf->box_y + config.margin_box_v + 4;
 	login->visible_len = len;
 	password->x = x;
 	password->y = buf->box_y + config.margin_box_v + 6;
 	password->visible_len = len;
 }
 static void doom_init(struct term_buf* buf)
 {
 	buf->init_width = buf->width;
 	buf->init_height = buf->height;
 	u16 tmp_len = buf->width * buf->height;
 	buf->tmp_buf = malloc(tmp_len);
 	tmp_len -= buf->width;
 	if (buf->tmp_buf == NULL)
 	{
 		dgn_throw(DGN_ALLOC);
 	}
 	memset(buf->tmp_buf, 0, tmp_len);
 	memset(buf->tmp_buf + tmp_len, DOOM_STEPS - 1, buf->width);
 }
 void animate_init(struct term_buf* buf)
 {
 	if (config.animate)
 	{
 		switch(config.animation)
 		{
 			default:
 			{
 				doom_init(buf);
 				break;
 			}
 		}
 	}
 }
 static void doom(struct term_buf* term_buf)
 {
 	static struct tb_cell fire[DOOM_STEPS] =
 	{
 		{' ', 9, 0}, // default
 		{0x2591, 2, 0}, // red
 		{0x2592, 2, 0}, // red
 		{0x2593, 2, 0}, // red
 		{0x2588, 2, 0}, // red
 		{0x2591, 4, 2}, // yellow
 		{0x2592, 4, 2}, // yellow
 		{0x2593, 4, 2}, // yellow
 		{0x2588, 4, 2}, // yellow
 		{0x2591, 8, 4}, // white
 		{0x2592, 8, 4}, // white
 		{0x2593, 8, 4}, // white
 		{0x2588, 8, 4}, // white
 	};
 	u16 src;
 	u16 random;
 	u16 dst;
 	u16 w = term_buf->init_width;
 	u8* tmp = term_buf->tmp_buf;
 	if ((term_buf->width != term_buf->init_width) || (term_buf->height != term_buf->init_height))
 	{
 		return;
 	}
 	struct tb_cell* buf = tb_cell_buffer();
 	for (u16 x = 0; x < w; ++x)
 	{
 		for (u16 y = 1; y < term_buf->init_height; ++y)
 		{
 			src = y * w + x;
 			random = ((rand() % 7) & 3);
 			dst = src - random + 1;
 			if (w > dst)
 			{
 				dst = 0;
 			}
 			else
 			{
 				dst -= w;
 			}
 			tmp[dst] = tmp[src] - (random & 1);
 			if (tmp[dst] > 12)
 			{
 				tmp[dst] = 0;
 			}
 			buf[dst] = fire[tmp[dst]];
 			buf[src] = fire[tmp[src]];
 		}
 	}
 }
 void animate(struct term_buf* buf)
 {
 	buf->width = tb_width();
 	buf->height = tb_height();
 	if (config.animate)
 	{
 		switch(config.animation)
 		{
 			default:
 			{
 				doom(buf);
 				break;
 			}
 		}
 	}
 }
 bool cascade(struct term_buf* term_buf, u8* fails)
 {
 	u16 width = term_buf->width;
 	u16 height = term_buf->height;
 	struct tb_cell* buf = tb_cell_buffer();
 	bool changes = false;
 	char c_under;
 	char c;
 	for (int i = height - 2; i >= 0; --i)
 	{
 		for (int k = 0; k < width; ++k)
 		{
 			c = buf[i * width + k].ch;
 			if (isspace(c))
 			{
 				continue;
 			}
 			c_under = buf[(i + 1) * width + k].ch;
 			if (!isspace(c_under))
 			{
 				continue;
 			}
 			if (!changes)
 			{
 				changes = true;
 			}
 			if ((rand() % 10) > 7)
 			{
 				continue;
 			}
 			buf[(i + 1) * width + k] = buf[i * width + k];
 			buf[i * width + k].ch = ' ';
 		}
 	}
 	// stop force-updating 
 	if (!changes)
 	{
 		sleep(7);
 		*fails = 0;
 		return false;
 	}
 	// force-update
 	return true;
 }
--- a/src/draw.h
+++ b/src/draw.h
@@ -0,0 +1,63 @@
 #ifndef H_LY_DRAW
 #define H_LY_DRAW
 #include "termbox.h"
 #include "ctypes.h"
 #include "inputs.h"
 struct box
 {
 	u32 left_up;
 	u32 left_down;
 	u32 right_up;
 	u32 right_down;
 	u32 top;
 	u32 bot;
 	u32 left;
 	u32 right;
 };
 struct term_buf
 {
 	u16 width;
 	u16 height;
 	u16 init_width;
 	u16 init_height;
 	struct box box_chars;
 	char* info_line;
 	u16 labels_max_len;
 	u16 box_x;
 	u16 box_y;
 	u16 box_width;
 	u16 box_height;
 	u8* tmp_buf;
 };
 void draw_init(struct term_buf* buf);
 void draw_free(struct term_buf* buf);
 void draw_box(struct term_buf* buf);
 struct tb_cell* strn_cell(char* s, u16 len);
 struct tb_cell* str_cell(char* s);
 void draw_labels(struct term_buf* buf);
 void draw_f_commands();
 void draw_lock_state(struct term_buf* buf);
 void draw_desktop(struct desktop* target);
 void draw_input(struct text* input);
 void draw_input_mask(struct text* input);
 void position_input(
 	struct term_buf* buf,
 	struct desktop* desktop,
 	struct text* login,
 	struct text* password);
 void animate_init(struct term_buf* buf);
 void animate(struct term_buf* buf);
 bool cascade(struct term_buf* buf, u8* fails);
 #endif
--- a/src/enums.zig
+++ b/src/enums.zig
@@ -1,18 +0,0 @@
 pub const Animation = enum {
    none,
    doom,
    matrix,
 };
 pub const DisplayServer = enum {
    wayland,
    shell,
    xinitrc,
    x11,
 };
 pub const Input = enum {
    session,
    login,
    password,
 };
--- a/src/inputs.c
+++ b/src/inputs.c
@@ -0,0 +1,268 @@
 #include "dragonfail.h"
 #include "termbox.h"
 #include "ctypes.h"
 #include "inputs.h"
 #include "config.h"
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
 void handle_desktop(void* input_struct, struct tb_event* event)
 {
 	struct desktop* target = (struct desktop*) input_struct;
 	if ((event != NULL) && (event->type == TB_EVENT_KEY))
 	{
 		if (event->key == TB_KEY_ARROW_LEFT)
 		{
 			input_desktop_right(target);
 		}
 		else if (event->key == TB_KEY_ARROW_RIGHT)
 		{
 			input_desktop_left(target);
 		}
 	}
 	tb_set_cursor(target->x + 2, target->y);
 }
 void handle_text(void* input_struct, struct tb_event* event)
 {
 	struct text* target = (struct text*) input_struct;
 	if ((event != NULL) && (event->type == TB_EVENT_KEY))
 	{
 		if (event->key == TB_KEY_ARROW_LEFT)
 		{
 			input_text_left(target);
 		}
 		else if (event->key == TB_KEY_ARROW_RIGHT)
 		{
 			input_text_right(target);
 		}
 		else if (event->key == TB_KEY_DELETE)
 		{
 			input_text_delete(target);
 		}
 		else if ((event->key == TB_KEY_BACKSPACE)
 			|| (event->key == TB_KEY_BACKSPACE2))
 		{
 			input_text_backspace(target);
 		}
 		else if (((event->ch > 31) && (event->ch < 127))
 			|| (event->key == TB_KEY_SPACE))
 		{
 			char buf[7] = {0};
 			if (event->key == TB_KEY_SPACE)
 			{
 				buf[0] = ' ';
 			}
 			else
 			{
 				utf8_unicode_to_char(buf, event->ch);
 			}
 			input_text_write(target, buf[0]);
 		}
 	}
 	tb_set_cursor(
 		target->x + (target->cur - target->visible_start),
 		target->y);
 }
 void input_desktop(struct desktop* target)
 {
 	target->list = NULL;
 	target->cmd = NULL;
 	target->display_server = NULL;
 	target->cur = 0;
 	target->len = 0;
 	input_desktop_add(target, strdup(lang.shell), strdup(""), DS_SHELL);
 	input_desktop_add(target, strdup(lang.xinitrc), strdup("~/.xinitrc"), DS_XINITRC);
 #if 0
 	input_desktop_add(target, strdup(lang.wayland), strdup(""), DS_WAYLAND);
 #endif
 }
 void input_text(struct text* target, u64 len)
 {
 	target->text = malloc(len + 1);
 	if (target->text == NULL)
 	{
 		dgn_throw(DGN_ALLOC);
 		return;
 	}
 	else
 	{
 		int ok = mlock(target->text, len + 1);
 		if (ok < 0)
 		{
 			dgn_throw(DGN_MLOCK);
 			return;
 		}
 		memset(target->text, 0, len + 1);
 	}
 	target->cur = target->text;
 	target->end = target->text;
 	target->visible_start = target->text;
 	target->len = len;
 	target->x = 0;
 	target->y = 0;
 }
 void input_desktop_free(struct desktop* target)
 {
 	if (target != NULL)
 	{
 		for (u16 i = 0; i < target->len; ++i)
 		{
 			if (target->list[i] != NULL)
 			{
 				free(target->list[i]);
 			}
 			if (target->cmd[i] != NULL)
 			{
 				free(target->cmd[i]);
 			}
 		}
 		free(target->list);
 		free(target->cmd);
 		free(target->display_server);
 	}
 }
 void input_text_free(struct text* target)
 {
 	memset(target->text, 0, target->len);
 	munlock(target->text, target->len + 1);
 	free(target->text);
 }
 void input_desktop_right(struct desktop* target)
 {
 	++(target->cur);
 	if (target->cur >= target->len)
 	{
 		target->cur = 0;
 	}
 }
 void input_desktop_left(struct desktop* target)
 {
 	--(target->cur);
 	if (target->cur >= target->len)
 	{
 		target->cur = target->len - 1;
 	}
 }
 void input_desktop_add(
 	struct desktop* target,
 	char* name,
 	char* cmd,
 	enum display_server display_server)
 {
 	++(target->len);
 	target->list = realloc(target->list, target->len * (sizeof (char*)));
 	target->cmd = realloc(target->cmd, target->len * (sizeof (char*)));
 	target->display_server = realloc(
 		target->display_server,
 		target->len * (sizeof (enum display_server)));
 	target->cur = target->len - 1;
 	if ((target->list == NULL)
 		|| (target->cmd == NULL)
 		|| (target->display_server == NULL))
 	{
 		dgn_throw(DGN_ALLOC);
 		return;
 	}
 	target->list[target->cur] = name;
 	target->cmd[target->cur] = cmd;
 	target->display_server[target->cur] = display_server;
 }
 void input_text_right(struct text* target)
 {
 	if (target->cur < target->end)
 	{
 		++(target->cur);
 		if ((target->cur - target->visible_start) > target->visible_len)
 		{
 			++(target->visible_start);
 		}
 	}
 }
 void input_text_left(struct text* target)
 {
 	if (target->cur > target->text)
 	{
 		--(target->cur);
 		if ((target->cur - target->visible_start) < 0)
 		{
 			--(target->visible_start);
 		}
 	}
 }
 void input_text_write(struct text* target, char ascii)
 {
 	if (ascii <= 0)
 	{
 		return; // unices do not support usernames and passwords other than ascii
 	}
 	if ((target->end - target->text + 1) < target->len)
 	{
 		// moves the text to the right to add space for the new ascii char
 		memcpy(target->cur + 1, target->cur, target->end - target->cur);
 		++(target->end);
 		// adds the new char and moves the cursor to the right
 		*(target->cur) = ascii;
 		input_text_right(target);
 	}
 }
 void input_text_delete(struct text* target)
 {
 	if (target->cur < target->end)
 	{
 		// moves the text on the right to overwrite the currently pointed char
 		memcpy(target->cur, target->cur + 1, target->end - target->cur + 1);
 		--(target->end);
 	}
 }
 void input_text_backspace(struct text* target)
 {
 	if (target->cur > target->text)
 	{
 		input_text_left(target);
 		input_text_delete(target);
 	}
 }
 void input_text_clear(struct text* target)
 {
 	memset(target->text, 0, target->len + 1);
 	target->cur = target->text;
 	target->end = target->text;
 	target->visible_start = target->text;
 }
--- a/src/inputs.h
+++ b/src/inputs.h
@@ -0,0 +1,55 @@
 #ifndef H_LY_INPUTS
 #define H_LY_INPUTS
 #include "termbox.h"
 #include "ctypes.h"
 enum display_server {DS_WAYLAND, DS_SHELL, DS_XINITRC, DS_XORG};
 struct text
 {
 	char* text;
 	char* end;
 	i64 len;
 	char* cur;
 	char* visible_start;
 	u16 visible_len;
 	u16 x;
 	u16 y;
 };
 struct desktop
 {
 	char** list;
 	char** cmd;
 	enum display_server* display_server;
 	u16 cur;
 	u16 len;
 	u16 visible_len;
 	u16 x;
 	u16 y;
 };
 void handle_desktop(void* input_struct, struct tb_event* event);
 void handle_text(void* input_struct, struct tb_event* event);
 void input_desktop(struct desktop* target);
 void input_text(struct text* target, u64 len);
 void input_desktop_free(struct desktop* target);
 void input_text_free(struct text* target);
 void input_desktop_right(struct desktop* target);
 void input_desktop_left(struct desktop* target);
 void input_desktop_add(
 	struct desktop* target,
 	char* name,
 	char* cmd,
 	enum display_server display_server);
 void input_text_right(struct text* target);
 void input_text_left(struct text* target);
 void input_text_write(struct text* target, char ascii);
 void input_text_delete(struct text* target);
 void input_text_backspace(struct text* target);
 void input_text_clear(struct text* target);
 #endif
--- a/src/interop.zig
+++ b/src/interop.zig
@@ -1,119 +0,0 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const Allocator = std.mem.Allocator;
 pub const termbox = @import("termbox2");
 pub const pam = @cImport({
    @cInclude("security/pam_appl.h");
 });
 pub const utmp = @cImport({
    @cInclude("utmp.h");
 });
 pub const xcb = @cImport({
    @cInclude("xcb/xcb.h");
 });
 pub const c_size = u64;
 pub const c_uid = u32;
 pub const c_gid = u32;
 pub const c_time = c_long;
 pub const tm = extern struct {
    tm_sec: c_int,
    tm_min: c_int,
    tm_hour: c_int,
    tm_mday: c_int,
    tm_mon: c_int,
    tm_year: c_int,
    tm_wday: c_int,
    tm_yday: c_int,
    tm_isdst: c_int,
 };
 pub const passwd = extern struct {
    pw_name: [*:0]u8,
    pw_passwd: [*:0]u8,
    pw_uid: c_uid,
    pw_gid: c_gid,
    pw_gecos: [*:0]u8,
    pw_dir: [*:0]u8,
    pw_shell: [*:0]u8,
 };
 pub const VT_ACTIVATE: c_int = 0x5606;
 pub const VT_WAITACTIVE: c_int = 0x5607;
 pub const KDGETLED: c_int = 0x4B31;
 pub const KDSETLED: c_int = 0x4B32;
 pub const KDGKBLED: c_int = 0x4B64;
 pub const KDSKBLED: c_int = 0x4B65;
 pub const LED_NUM: c_int = 0x02;
 pub const LED_CAP: c_int = 0x04;
 pub const K_NUMLOCK: c_int = 0x02;
 pub const K_CAPSLOCK: c_int = 0x04;
 pub extern "c" fn localtime(timer: *const c_time) *tm;
 pub extern "c" fn strftime(str: [*:0]u8, maxsize: c_size, format: [*:0]const u8, timeptr: *const tm) c_size;
 pub extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
 pub extern "c" fn putenv(name: [*:0]u8) c_int;
 pub extern "c" fn getuid() c_uid;
 pub extern "c" fn getpwnam(name: [*:0]const u8) ?*passwd;
 pub extern "c" fn endpwent() void;
 pub extern "c" fn setusershell() void;
 pub extern "c" fn getusershell() [*:0]u8;
 pub extern "c" fn endusershell() void;
 pub extern "c" fn initgroups(user: [*:0]const u8, group: c_gid) c_int;
 pub fn timeAsString(buf: [:0]u8, format: [:0]const u8) ![]u8 {
    const timer = std.time.timestamp();
    const tm_info = localtime(&timer);
    const len = strftime(buf, buf.len, format, tm_info);
    if (len < 0) return error.CannotGetFormattedTime;
    return buf[0..len];
 }
 pub fn getLockState(console_dev: [:0]const u8) !struct {
    numlock: bool,
    capslock: bool,
 } {
    const fd = std.c.open(console_dev, .{ .ACCMODE = .RDONLY });
    if (fd < 0) return error.CannotOpenConsoleDev;
    defer _ = std.c.close(fd);
    var numlock = false;
    var capslock = false;
    if (builtin.os.tag.isBSD()) {
        var led: c_int = undefined;
        _ = std.c.ioctl(fd, KDGETLED, &led);
        numlock = (led & LED_NUM) != 0;
        capslock = (led & LED_CAP) != 0;
    } else {
        var led: c_char = undefined;
        _ = std.c.ioctl(fd, KDGKBLED, &led);
        numlock = (led & K_NUMLOCK) != 0;
        capslock = (led & K_CAPSLOCK) != 0;
    }
    return .{
        .numlock = numlock,
        .capslock = capslock,
    };
 }
 pub fn setNumlock(val: bool) !void {
    var led: c_char = undefined;
    _ = std.c.ioctl(0, KDGKBLED, &led);
    const numlock = (led & K_NUMLOCK) != 0;
    if (numlock != val) {
        const status = std.c.ioctl(std.posix.STDIN_FILENO, KDSKBLED, led ^ K_NUMLOCK);
        if (status != 0) return error.FailedToSetNumlock;
    }
 }
--- a/src/login.c
+++ b/src/login.c
@@ -0,0 +1,680 @@
 #include "dragonfail.h"
 #include "termbox.h"
 #include "inputs.h"
 #include "draw.h"
 #include "utils.h"
 #include "config.h"
 #include "login.h"
 #include <errno.h>
 #include <grp.h>
 #include <pwd.h>
 #include <security/pam_appl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <utmp.h>
 #include <xcb/xcb.h>
 int get_free_display()
 {
 	char xlock[1024];
 	u8 i;
 	for (i = 0; i < 200; ++i)
 	{
 		snprintf(xlock, 1024, "/tmp/.X%d-lock", i);
 		if (access(xlock, F_OK) == -1)
 		{
 			break;
 		}
 	}
 	return i;
 }
 void reset_terminal(struct passwd* pwd)
 {
 	pid_t pid = fork();
 	if (pid == 0)
 	{
 		execl(pwd->pw_shell, pwd->pw_shell, "-c", config.term_reset_cmd, NULL);
 		exit(EXIT_SUCCESS);
 	}
 	int status;
 	waitpid(pid, &status, 0);
 }
 int login_conv(
 	int num_msg,
 	const struct pam_message** msg,
 	struct pam_response** resp,
 	void* appdata_ptr)
 {
 	*resp = calloc(num_msg, sizeof (struct pam_response));
 	if (*resp == NULL)
 	{
 		return PAM_BUF_ERR;
 	}
 	char* username;
 	char* password;
 	int ok = PAM_SUCCESS;
 	int i;
 	for (i = 0; i < num_msg; ++i)
 	{
 		switch (msg[i]->msg_style)
 		{
 			case PAM_PROMPT_ECHO_ON:
 			{
 				username = ((char**) appdata_ptr)[0];
 				(*resp)[i].resp = strdup(username);
 				break;
 			}
 			case PAM_PROMPT_ECHO_OFF:
 			{
 				password = ((char**) appdata_ptr)[1];
 				(*resp)[i].resp = strdup(password);
 				break;
 			}
 			case PAM_ERROR_MSG:
 			{
 				ok = PAM_CONV_ERR;
 				break;
 			}
 		}
 		if (ok != PAM_SUCCESS)
 		{
 			break;
 		}
 	}
 	if (ok != PAM_SUCCESS)
 	{
 		for (i = 0; i < num_msg; ++i)
 		{
 			if ((*resp)[i].resp == NULL)
 			{
 				continue;
 			}
 			free((*resp)[i].resp);
 			(*resp)[i].resp = NULL;
 		}
 		free(*resp);
 		*resp = NULL;
 	}
 	return ok;
 }
 void pam_diagnose(int error, struct term_buf* buf)
 {
 	switch (error)
 	{
 		case PAM_ACCT_EXPIRED:
 		{
 			buf->info_line = lang.err_pam_acct_expired;
 			break;
 		}
 		case PAM_AUTH_ERR:
 		{
 			buf->info_line = lang.err_pam_auth;
 			break;
 		}
 		case PAM_AUTHINFO_UNAVAIL:
 		{
 			buf->info_line = lang.err_pam_authinfo_unavail;
 			break;
 		}
 		case PAM_BUF_ERR:
 		{
 			buf->info_line = lang.err_pam_buf;
 			break;
 		}
 		case PAM_CRED_ERR:
 		{
 			buf->info_line = lang.err_pam_cred_err;
 			break;
 		}
 		case PAM_CRED_EXPIRED:
 		{
 			buf->info_line = lang.err_pam_cred_expired;
 			break;
 		}
 		case PAM_CRED_INSUFFICIENT:
 		{
 			buf->info_line = lang.err_pam_cred_insufficient;
 			break;
 		}
 		case PAM_CRED_UNAVAIL:
 		{
 			buf->info_line = lang.err_pam_cred_unavail;
 			break;
 		}
 		case PAM_MAXTRIES:
 		{
 			buf->info_line = lang.err_pam_maxtries;
 			break;
 		}
 		case PAM_NEW_AUTHTOK_REQD:
 		{
 			buf->info_line = lang.err_pam_authok_reqd;
 			break;
 		}
 		case PAM_PERM_DENIED:
 		{
 			buf->info_line = lang.err_pam_perm_denied;
 			break;
 		}
 		case PAM_SESSION_ERR:
 		{
 			buf->info_line = lang.err_pam_session;
 			break;
 		}
 		case PAM_SYSTEM_ERR:
 		{
 			buf->info_line = lang.err_pam_sys;
 			break;
 		}
 		case PAM_USER_UNKNOWN:
 		{
 			buf->info_line = lang.err_pam_user_unknown;
 			break;
 		}
 		case PAM_ABORT:
 		default:
 		{
 			buf->info_line = lang.err_pam_abort;
 			break;
 		}
 	}
 	dgn_throw(DGN_PAM);
 }
 void env_init(struct passwd* pwd)
 {
 	extern char** environ;
 	char* term = getenv("TERM");
 	char* lang = getenv("LANG");
 	// clean env
 	environ[0] = NULL;
 	if (term != NULL)
 	{
 		setenv("TERM", term, 1);
 	}
 	else
 	{
 		setenv("TERM", "linux", 1);
 	}
 	setenv("HOME", pwd->pw_dir, 1);
 	setenv("PWD", pwd->pw_dir, 1);
 	setenv("SHELL", pwd->pw_shell, 1);
 	setenv("USER", pwd->pw_name, 1);
 	setenv("LOGNAME", pwd->pw_name, 1);
 	setenv("LANG", lang, 1);
 	// Set PATH if specified in the configuration
 	if (strlen(config.path))
 	{
 		int ok = setenv("PATH", config.path, 1);
 		if (ok != 0)
 		{
 			dgn_throw(DGN_PATH);
 		}
 	}
 }
 void env_xdg(const char* tty_id, const enum display_server display_server)
 {
 	char user[15];
 	snprintf(user, 15, "/run/user/%d", getuid());
 	setenv("XDG_RUNTIME_DIR", user, 0);
 	setenv("XDG_SESSION_CLASS", "user", 0);
 	setenv("XDG_SEAT", "seat0", 0);
 	setenv("XDG_VTNR", tty_id, 0);
 	switch (display_server)
 	{
 		case DS_WAYLAND:
 		{
 			setenv("XDG_SESSION_TYPE", "wayland", 1);
 			break;
 		}
 		case DS_SHELL:
 		{
 			setenv("XDG_SESSION_TYPE", "tty", 0);
 			break;
 		}
 		case DS_XINITRC:
 		case DS_XORG:
 		{
 			setenv("XDG_SESSION_TYPE", "x11", 0);
 			break;
 		}
 	}
 }
 void add_utmp_entry(
 	struct utmp *entry,
 	char *username,
 	pid_t display_pid
 ) {
 	entry->ut_type = USER_PROCESS;
 	entry->ut_pid = display_pid;
 	strcpy(entry->ut_line, ttyname(STDIN_FILENO) + strlen("/dev/"));
 	/* only correct for ptys named /dev/tty[pqr][0-9a-z] */
 	strcpy(entry->ut_id, ttyname(STDIN_FILENO) + strlen("/dev/tty"));
 	time((long int *) &entry->ut_time);
 	strncpy(entry->ut_user, username, UT_NAMESIZE);
 	memset(entry->ut_host, 0, UT_HOSTSIZE);
 	entry->ut_addr = 0;
 	setutent();
 	pututline(entry);
 }
 void remove_utmp_entry(struct utmp *entry) {
 	entry->ut_type = DEAD_PROCESS;
 	memset(entry->ut_line, 0, UT_LINESIZE);
 	entry->ut_time = 0;
 	memset(entry->ut_user, 0, UT_NAMESIZE);
 	setutent();
 	pututline(entry);
 	endutent();
 }
 void xauth(const char* display_name, const char* shell, const char* dir)
 {
 	char xauthority[256];
 	snprintf(xauthority, 256, "%s/%s", dir, ".lyxauth");
 	setenv("XAUTHORITY", xauthority, 1);
 	setenv("DISPLAY", display_name, 1);
 	FILE* fp = fopen(xauthority, "ab+");
 	if (fp != NULL)
 	{
 		fclose(fp);
 	}
 	pid_t pid = fork();
 	if (pid == 0)
 	{
 		char cmd[1024];
 		snprintf(
 			cmd,
 			1024,
 			"%s add %s . `%s`",
 			config.xauth_cmd,
 			display_name,
 			config.mcookie_cmd);
 		execl(shell, shell, "-c", cmd, NULL);
 		exit(EXIT_SUCCESS);
 	}
 	int status;
 	waitpid(pid, &status, 0);
 }
 void xorg(
 	struct passwd* pwd,
 	const char* vt,
 	const char* desktop_cmd)
 {
 	// generate xauthority file
 	const char* xauth_dir = getenv("XDG_CONFIG_HOME");
 	if ((xauth_dir == NULL) || (*xauth_dir == '\0'))
 	{
 		xauth_dir = pwd->pw_dir;
 	}
 	char display_name[4];
 	snprintf(display_name, 3, ":%d", get_free_display());
 	xauth(display_name, pwd->pw_shell, xauth_dir);
 	// start xorg
 	pid_t pid = fork();
 	if (pid == 0)
 	{
 		char x_cmd[1024];
 		snprintf(
 			x_cmd,
 			1024,
 			"%s %s %s",
 			config.x_cmd,
 			display_name,
 			vt);
 		execl(pwd->pw_shell, pwd->pw_shell, "-c", x_cmd, NULL);
 		exit(EXIT_SUCCESS);
 	}
 	int ok;
 	xcb_connection_t* xcb;
 	do
 	{
 		xcb = xcb_connect(NULL, NULL);
 		ok = xcb_connection_has_error(xcb);
 		kill(pid, 0);
 	}
 	while((ok != 0) && (errno != ESRCH));
 	if (ok != 0)
 	{
 		return;
 	}
 	pid_t xorg_pid = fork();
 	if (xorg_pid == 0)
 	{
 		char de_cmd[1024];
 		snprintf(
 			de_cmd,
 			1024,
 			"%s %s",
 			config.x_cmd_setup,
 			desktop_cmd);
 		execl(pwd->pw_shell, pwd->pw_shell, "-c", de_cmd, NULL);
 		exit(EXIT_SUCCESS);
 	}
 	int status;
 	waitpid(xorg_pid, &status, 0);
 	xcb_disconnect(xcb);
 	kill(pid, 0);
 	if (errno != ESRCH)
 	{
 		kill(pid, SIGTERM);
 		waitpid(pid, &status, 0);
 	}
 }
 void wayland(
 	struct passwd* pwd,
 	const char* desktop_cmd)
 {
 	char cmd[1024];
 	snprintf(cmd, 1024, "%s %s", config.wayland_cmd, desktop_cmd);
 	execl(pwd->pw_shell, pwd->pw_shell, "-c", cmd, NULL);
 }
 void shell(struct passwd* pwd)
 {
 	const char* pos = strrchr(pwd->pw_shell, '/');
 	char args[1024];
 	args[0] = '-';
 	if (pos != NULL)
 	{
 		pos = pos + 1;
 	}
 	else
 	{
 		pos = pwd->pw_shell;
 	}
 	strncpy(args + 1, pos, 1023);
 	execl(pwd->pw_shell, args, NULL);
 }
 // pam_do performs the pam action specified in pam_action
 // on pam_action fail, call diagnose and end pam session
 int pam_do(
 	int (pam_action)(struct pam_handle *, int),
 	struct pam_handle *handle,
 	int flags,
 	struct term_buf *buf)
 {
 	int status = pam_action(handle, flags);
 	if (status != PAM_SUCCESS) {
 		pam_diagnose(status, buf);
 		pam_end(handle, status);
 	}
 	return status;
 }
 void auth(
 	struct desktop* desktop,
 	struct text* login,
 	struct text* password,
 	struct term_buf* buf)
 {
 	int ok;
 	// open pam session
 	const char* creds[2] = {login->text, password->text};
 	struct pam_conv conv = {login_conv, creds};
 	struct pam_handle* handle;
 	ok = pam_start(config.service_name, NULL, &conv, &handle);
 	if (ok != PAM_SUCCESS)
 	{
 		pam_diagnose(ok, buf);
 		pam_end(handle, ok);
 		return;
 	}
 	ok = pam_do(pam_authenticate, handle, 0, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	ok = pam_do(pam_acct_mgmt, handle, 0, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	ok = pam_do(pam_setcred, handle, PAM_ESTABLISH_CRED, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	ok = pam_do(pam_open_session, handle, 0, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	// clear the credentials
 	input_text_clear(password);
 	// get passwd structure
 	struct passwd* pwd = getpwnam(login->text);
 	endpwent();
 	if (pwd == NULL)
 	{
 		dgn_throw(DGN_PWNAM);
 		pam_end(handle, ok);
 		return;
 	}
 	// set user shell
 	if (pwd->pw_shell[0] == '\0')
 	{
 		setusershell();
 		char* shell = getusershell();
 		if (shell != NULL)
 		{
 			strcpy(pwd->pw_shell, shell);
 		}
 		endusershell();
 	}
 	// restore regular terminal mode
 	tb_clear();
 	tb_present();
 	tb_shutdown();
 	// start desktop environment
 	pid_t pid = fork();
 	if (pid == 0)
 	{
 		// set user info 
 		ok = initgroups(pwd->pw_name, pwd->pw_gid);
 		if (ok != 0)
 		{
 			dgn_throw(DGN_USER_INIT);
 			exit(EXIT_FAILURE);
 		}
 		ok = setgid(pwd->pw_gid);
 		if (ok != 0)
 		{
 			dgn_throw(DGN_USER_GID);
 			exit(EXIT_FAILURE);
 		}
 		ok = setuid(pwd->pw_uid);
 		if (ok != 0)
 		{
 			dgn_throw(DGN_USER_UID);
 			exit(EXIT_FAILURE);
 		}
 		// get a display
 		char tty_id [3];
 		char vt[5];
 		snprintf(tty_id, 3, "%d", config.tty);
 		snprintf(vt, 5, "vt%d", config.tty);
 		// set env
 		env_init(pwd);
 		if (dgn_catch())
 		{
 			exit(EXIT_FAILURE);
 		}
 		// add pam variables
 		char** env = pam_getenvlist(handle);
 		for (u16 i = 0; env && env[i]; ++i)
 		{
 			putenv(env[i]);
 		}
 		// add xdg variables
 		env_xdg(tty_id, desktop->display_server[desktop->cur]);
 		// execute
 		int ok = chdir(pwd->pw_dir);
 		if (ok != 0)
 		{
 			dgn_throw(DGN_CHDIR);
 			exit(EXIT_FAILURE);
 		}
 		reset_terminal(pwd);
 		switch (desktop->display_server[desktop->cur])
 		{
 			case DS_WAYLAND:
 			{
 				wayland(pwd, desktop->cmd[desktop->cur]);
 				break;
 			}
 			case DS_SHELL:
 			{
 				shell(pwd);
 				break;
 			}
 			case DS_XINITRC:
 			case DS_XORG:
 			{
 				xorg(pwd, vt, desktop->cmd[desktop->cur]);
 				break;
 			}
 		}
 		exit(EXIT_SUCCESS);
 	}
 	// add utmp audit
 	struct utmp entry;
 	add_utmp_entry(&entry, pwd->pw_name, pid);
 	// wait for the session to stop
 	int status;
 	waitpid(pid, &status, 0);
 	remove_utmp_entry(&entry);
 	reset_terminal(pwd);
 	// reinit termbox
 	tb_init();
 	tb_select_output_mode(TB_OUTPUT_NORMAL);
 	// reload the desktop environment list on logout
 	input_desktop_free(desktop);
 	input_desktop(desktop);
 	desktop_load(desktop);
 	// close pam session
 	ok = pam_do(pam_close_session, handle, 0, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	ok = pam_do(pam_setcred, handle, PAM_DELETE_CRED, buf);
 	if (ok != PAM_SUCCESS)
 	{
 		return;
 	}
 	ok = pam_end(handle, 0);
 	if (ok != PAM_SUCCESS)
 	{
 		pam_diagnose(ok, buf);
 	}
 }
--- a/src/login.h
+++ b/src/login.h
@@ -0,0 +1,13 @@
 #ifndef H_LY_LOGIN
 #define H_LY_LOGIN
 #include "draw.h"
 #include "inputs.h"
 void auth(
 	struct desktop* desktop,
 	struct text* login,
 	struct text* password,
 	struct term_buf* buf);
 #endif
--- a/src/main.c
+++ b/src/main.c
@@ -0,0 +1,315 @@
 #include "argoat.h"
 #include "configator.h"
 #include "dragonfail.h"
 #include "termbox.h"
 #include "ctypes.h"
 #include "draw.h"
 #include "inputs.h"
 #include "login.h"
 #include "utils.h"
 #include "config.h"
 #include <stddef.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #define ARG_COUNT 7
 // things you can define:
 // GIT_VERSION_STRING
 // global
 struct lang lang;
 struct config config;
 // args handles
 void arg_help(void* data, char** pars, const int pars_count)
 {
 	printf("RTFM\n");
 }
 void arg_version(void* data, char** pars, const int pars_count)
 {
 #ifdef GIT_VERSION_STRING
 	printf("Ly version %s\n", GIT_VERSION_STRING);
 #else
 	printf("Ly version unknown\n");
 #endif
 }
 // low-level error messages
 void log_init(char** log)
 {
 	log[DGN_OK] = lang.err_dgn_oob;
 	log[DGN_NULL] = lang.err_null;
 	log[DGN_ALLOC] = lang.err_alloc;
 	log[DGN_BOUNDS] = lang.err_bounds;
 	log[DGN_DOMAIN] = lang.err_domain;
 	log[DGN_MLOCK] = lang.err_mlock;
 	log[DGN_XSESSIONS_DIR] = lang.err_xsessions_dir;
 	log[DGN_XSESSIONS_OPEN] = lang.err_xsessions_open;
 	log[DGN_PATH] = lang.err_path;
 	log[DGN_CHDIR] = lang.err_chdir;
 	log[DGN_PWNAM] = lang.err_pwnam;
 	log[DGN_USER_INIT] = lang.err_user_init;
 	log[DGN_USER_GID] = lang.err_user_gid;
 	log[DGN_USER_UID] = lang.err_user_uid;
 	log[DGN_PAM] = lang.err_pam;
 	log[DGN_HOSTNAME] = lang.err_hostname;
 }
 void arg_config(void* data, char** pars, const int pars_count)
 {
 	*((char **)data) = *pars;
 }
 // ly!
 int main(int argc, char** argv)
 {
 	// init error lib
 	log_init(dgn_init());
 	// load config
 	config_defaults();
 	lang_defaults();
 	char *config_path = NULL;
 	// parse args
 	const struct argoat_sprig sprigs[ARG_COUNT] =
 	{
 		{NULL, 0, NULL, NULL},
 		{"config", 0, &config_path, arg_config},
 		{"c", 0, &config_path, arg_config},
 		{"help", 0, NULL, arg_help},
 		{"h", 0, NULL, arg_help},
 		{"version", 0, NULL, arg_version},
 		{"v", 0, NULL, arg_version},
 	};
 	struct argoat args = {sprigs, ARG_COUNT, NULL, 0, 0};
 	argoat_graze(&args, argc, argv);
 	// init inputs
 	struct desktop desktop;
 	struct text login;
 	struct text password;
 	input_desktop(&desktop);
 	input_text(&login, config.max_login_len);
 	input_text(&password, config.max_password_len);
 	if (dgn_catch())
 	{
 		config_free();
 		lang_free();
 		return 1;
 	}
 	config_load(config_path);
 	if (strcmp(config.lang, "en") != 0)
 	{
 		lang_load();
 	}
 	void* input_structs[3] =
 	{
 		(void*) &desktop,
 		(void*) &login,
 		(void*) &password,
 	};
 	void (*input_handles[3]) (void*, struct tb_event*) =
 	{
 		handle_desktop,
 		handle_text,
 		handle_text,
 	};
 	desktop_load(&desktop);
 	load(&desktop, &login);
 	// start termbox
 	tb_init();
 	tb_select_output_mode(TB_OUTPUT_NORMAL);
 	tb_clear();
 	// init visible elements
 	struct tb_event event;
 	struct term_buf buf;
 	u8 active_input = config.default_input;
 	(*input_handles[active_input])(input_structs[active_input], NULL);
 	// init drawing stuff
 	draw_init(&buf);
 	if (config.animate)
 	{
 		animate_init(&buf);
 		if (dgn_catch())
 		{
 			config.animate = false;
 			dgn_reset();
 		}
 	}
 	// init state info
 	int error;
 	bool run = true;
 	bool update = true;
 	bool reboot = false;
 	bool shutdown = false;
 	u8 auth_fails = 0;
 	switch_tty(&buf);
 	// main loop
 	while (run)
 	{
 		if (update)
 		{
 			if (auth_fails < 10)
 			{
 				tb_clear();
 				animate(&buf);
 				draw_box(&buf);
 				draw_labels(&buf);
 				draw_f_commands();
 				draw_lock_state(&buf);
 				position_input(&buf, &desktop, &login, &password);
 				draw_desktop(&desktop);
 				draw_input(&login);
 				draw_input_mask(&password);
 				update = config.animate;
 			}
 			else
 			{
 				usleep(10000);
 				update = cascade(&buf, &auth_fails);
 			}
 			tb_present();
 		}
 		error = tb_peek_event(&event, config.min_refresh_delta);
 		if (error < 0)
 		{
 			continue;
 		}
 		if (event.type == TB_EVENT_KEY)
 		{
 			switch (event.key)
 			{
 			case TB_KEY_F1:
 				shutdown = true;
 				run = false;
 				break;
 			case TB_KEY_F2:
 				reboot = true;
 				run = false;
 				break;
 			case TB_KEY_CTRL_C:
 				run = false;
 				break;
 			case TB_KEY_CTRL_U:
 				if (active_input > 0)
 				{
 					input_text_clear(input_structs[active_input]);
 				}
 				break;
 			case TB_KEY_ARROW_UP:
 				if (active_input > 0)
 				{
 					--active_input;
 					update = true;
 				}
 				break;
 			case TB_KEY_ARROW_DOWN:
 				if (active_input < 2)
 				{
 					++active_input;
 					update = true;
 				}
 				break;
 			case TB_KEY_TAB:
 				++active_input;
 				if (active_input > 2)
 				{
 					active_input = PASSWORD_INPUT;
 				}
 				update = true;
 				break;
 			case TB_KEY_ENTER:
 				save(&desktop, &login);
 				auth(&desktop, &login, &password, &buf);
 				update = true;
 				if (dgn_catch())
 				{
 					++auth_fails;
 					// move focus back to password input
 					active_input = PASSWORD_INPUT;
 					if (dgn_output_code() != DGN_PAM)
 					{
 						buf.info_line = dgn_output_log();
 					}
 					if (config.blank_password)
 					{
 						input_text_clear(&password);
 					}
 					dgn_reset();
 				}
 				else
 				{
 					buf.info_line = lang.logout;
 				}
 				load(&desktop, &login);
 				system("tput cnorm");
 				break;
 			default:
 				(*input_handles[active_input])(
 					input_structs[active_input],
 					&event);
 				update = true;
 				break;
 			}
 		}
 	}
 	// stop termbox
 	tb_shutdown();
 	// free inputs
 	input_desktop_free(&desktop);
 	input_text_free(&login);
 	input_text_free(&password);
 	free_hostname();
 	// unload config
 	draw_free(&buf);
 	lang_free();
 	if (shutdown)
 	{
 		execl("/bin/sh", "sh", "-c", config.shutdown_cmd, NULL);
 	}
 	if (reboot)
 	{
 		execl("/bin/sh", "sh", "-c", config.restart_cmd, NULL);
 	}
 	config_free();
 	return 0;
 }
--- a/src/main.zig
+++ b/src/main.zig
@@ -1,695 +0,0 @@
 const std = @import("std");
 const build_options = @import("build_options");
 const builtin = @import("builtin");
 const clap = @import("clap");
 const ini = @import("zigini");
 const auth = @import("auth.zig");
 const bigclock = @import("bigclock.zig");
 const interop = @import("interop.zig");
 const Doom = @import("animations/Doom.zig");
 const Matrix = @import("animations/Matrix.zig");
 const TerminalBuffer = @import("tui/TerminalBuffer.zig");
 const Desktop = @import("tui/components/Desktop.zig");
 const Text = @import("tui/components/Text.zig");
 const InfoLine = @import("tui/components/InfoLine.zig");
 const Config = @import("config/Config.zig");
 const Lang = @import("config/Lang.zig");
 const Save = @import("config/Save.zig");
 const migrator = @import("config/migrator.zig");
 const SharedError = @import("SharedError.zig");
 const utils = @import("tui/utils.zig");
 const Ini = ini.Ini;
 const termbox = interop.termbox;
 const temporary_allocator = std.heap.page_allocator;
 var session_pid: std.posix.pid_t = -1;
 pub fn signalHandler(i: c_int) callconv(.C) void {
    if (session_pid == 0) return;
    // Forward signal to session to clean up
    if (session_pid > 0) {
        _ = std.c.kill(session_pid, i);
        var status: c_int = 0;
        _ = std.c.waitpid(session_pid, &status, 0);
    }
    _ = termbox.tb_shutdown();
    std.c.exit(i);
 }
 pub fn main() !void {
    var shutdown = false;
    var restart = false;
    var shutdown_cmd: []const u8 = undefined;
    var restart_cmd: []const u8 = undefined;
    const stderr = std.io.getStdErr().writer();
    defer {
        // If we can't shutdown or restart due to an error, we print it to standard error. If that fails, just bail out
        if (shutdown) {
            const shutdown_error = std.process.execv(temporary_allocator, &[_][]const u8{ "/bin/sh", "-c", shutdown_cmd });
            stderr.print("error: couldn't shutdown: {any}\n", .{shutdown_error}) catch std.process.exit(1);
        } else if (restart) {
            const restart_error = std.process.execv(temporary_allocator, &[_][]const u8{ "/bin/sh", "-c", restart_cmd });
            stderr.print("error: couldn't restart: {any}\n", .{restart_error}) catch std.process.exit(1);
        } else {
            // The user has quit Ly using Ctrl+C
            temporary_allocator.free(shutdown_cmd);
            temporary_allocator.free(restart_cmd);
        }
    }
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    // Load arguments
    const params = comptime clap.parseParamsComptime(
        \\-h, --help                Shows all commands.
        \\-v, --version             Shows the version of Ly.
        \\-c, --config <str>        Overrides the default configuration path. Example: --config /usr/share/ly
    );
    var diag = clap.Diagnostic{};
    var res = clap.parse(clap.Help, &params, clap.parsers.default, .{ .diagnostic = &diag, .allocator = allocator }) catch |err| {
        diag.report(stderr, err) catch {};
        return err;
    };
    defer res.deinit();
    var config: Config = undefined;
    var lang: Lang = undefined;
    var save: Save = undefined;
    var info_line = InfoLine{};
    if (res.args.help != 0) {
        try clap.help(stderr, clap.Help, &params, .{});
        _ = try stderr.write("Note: if you want to configure Ly, please check the config file, which is usually located at /etc/ly/config.ini.\n");
        std.process.exit(0);
    }
    if (res.args.version != 0) {
        _ = try stderr.write("Ly version " ++ build_options.version ++ "\n");
        std.process.exit(0);
    }
    // Load configuration file
    var config_ini = Ini(Config).init(allocator);
    defer config_ini.deinit();
    var lang_ini = Ini(Lang).init(allocator);
    defer lang_ini.deinit();
    var save_ini = Ini(Save).init(allocator);
    defer save_ini.deinit();
    var save_path: []const u8 = build_options.data_directory ++ "/save.ini";
    var save_path_alloc = false;
    defer {
        if (save_path_alloc) allocator.free(save_path);
    }
    const comment_characters = "#";
    if (res.args.config) |s| {
        const trailing_slash = if (s[s.len - 1] != '/') "/" else "";
        const config_path = try std.fmt.allocPrint(allocator, "{s}{s}config.ini", .{ s, trailing_slash });
        defer allocator.free(config_path);
        config = config_ini.readFileToStruct(config_path, comment_characters, migrator.configFieldHandler) catch Config{};
        const lang_path = try std.fmt.allocPrint(allocator, "{s}{s}lang/{s}.ini", .{ s, trailing_slash, config.lang });
        defer allocator.free(lang_path);
        lang = lang_ini.readFileToStruct(lang_path, comment_characters, null) catch Lang{};
        if (config.load) {
            save_path = try std.fmt.allocPrint(allocator, "{s}{s}save.ini", .{ s, trailing_slash });
            save_path_alloc = true;
            var user_buf: [32]u8 = undefined;
            save = save_ini.readFileToStruct(save_path, comment_characters, null) catch migrator.tryMigrateSaveFile(&user_buf, config.save_file);
        }
    } else {
        const config_path = build_options.data_directory ++ "/config.ini";
        config = config_ini.readFileToStruct(config_path, comment_characters, migrator.configFieldHandler) catch Config{};
        const lang_path = try std.fmt.allocPrint(allocator, "{s}/lang/{s}.ini", .{ build_options.data_directory, config.lang });
        defer allocator.free(lang_path);
        lang = lang_ini.readFileToStruct(lang_path, comment_characters, null) catch Lang{};
        if (config.load) {
            var user_buf: [32]u8 = undefined;
            save = save_ini.readFileToStruct(save_path, comment_characters, null) catch migrator.tryMigrateSaveFile(&user_buf, config.save_file);
        }
    }
    // These strings only end up getting freed if the user quits Ly using Ctrl+C, which is fine since in the other cases
    // we end up shutting down or restarting the system
    shutdown_cmd = try temporary_allocator.dupe(u8, config.shutdown_cmd);
    restart_cmd = try temporary_allocator.dupe(u8, config.restart_cmd);
    interop.setNumlock(config.numlock) catch {};
    if (config.initial_info_text) |text| {
        try info_line.setText(text);
    } else get_host_name: {
        // Initialize information line with host name
        var name_buf: [std.posix.HOST_NAME_MAX]u8 = undefined;
        const hostname = std.posix.gethostname(&name_buf) catch {
            try info_line.setText(lang.err_hostname);
            break :get_host_name;
        };
        try info_line.setText(hostname);
    }
    // Initialize termbox
    _ = termbox.tb_init();
    defer _ = termbox.tb_shutdown();
    const act = std.posix.Sigaction{
        .handler = .{ .handler = &signalHandler },
        .mask = std.posix.empty_sigset,
        .flags = 0,
    };
    try std.posix.sigaction(std.posix.SIG.TERM, &act, null);
    _ = termbox.tb_set_output_mode(termbox.TB_OUTPUT_NORMAL);
    _ = termbox.tb_clear();
    // Needed to reset termbox after auth
    const tb_termios = try std.posix.tcgetattr(std.posix.STDIN_FILENO);
    // Initialize terminal buffer
    const labels_max_length = @max(lang.login.len, lang.password.len);
    // Get a random seed for the PRNG (used by animations)
    var seed: u64 = undefined;
    try std.posix.getrandom(std.mem.asBytes(&seed));
    var prng = std.Random.DefaultPrng.init(seed);
    const random = prng.random();
    var buffer = TerminalBuffer.init(config, labels_max_length, random);
    // Initialize components
    var desktop = try Desktop.init(allocator, &buffer, config.max_desktop_len, lang);
    defer desktop.deinit();
    desktop.addEnvironment(.{ .Name = lang.shell }, "", .shell) catch {
        try info_line.setText(lang.err_alloc);
    };
    if (config.xinitrc) |xinitrc| {
        desktop.addEnvironment(.{ .Name = lang.xinitrc, .Exec = xinitrc }, "", .xinitrc) catch {
            try info_line.setText(lang.err_alloc);
        };
    }
    try desktop.crawl(config.waylandsessions, .wayland);
    try desktop.crawl(config.xsessions, .x11);
    var login = try Text.init(allocator, &buffer, config.max_login_len);
    defer login.deinit();
    var password = try Text.init(allocator, &buffer, config.max_password_len);
    defer password.deinit();
    var active_input = config.default_input;
    var insert_mode = !config.vi_mode;
    // Load last saved username and desktop selection, if any
    if (config.load) {
        if (save.user) |user| {
            try login.text.appendSlice(user);
            login.end = user.len;
            login.cursor = login.end;
            active_input = .password;
        }
        if (save.session_index) |session_index| {
            if (session_index < desktop.environments.items.len) desktop.current = session_index;
        }
    }
    // Place components on the screen
    {
        buffer.drawBoxCenter(!config.hide_borders, config.blank_box);
        const coordinates = buffer.calculateComponentCoordinates();
        desktop.position(coordinates.x, coordinates.y + 2, coordinates.visible_length);
        login.position(coordinates.x, coordinates.y + 4, coordinates.visible_length);
        password.position(coordinates.x, coordinates.y + 6, coordinates.visible_length);
        switch (active_input) {
            .session => desktop.handle(null, insert_mode),
            .login => login.handle(null, insert_mode) catch {
                try info_line.setText(lang.err_alloc);
            },
            .password => password.handle(null, insert_mode) catch {
                try info_line.setText(lang.err_alloc);
            },
        }
    }
    // Initialize the animation, if any
    var doom: Doom = undefined;
    var matrix: Matrix = undefined;
    switch (config.animation) {
        .none => {},
        .doom => doom = try Doom.init(allocator, &buffer),
        .matrix => matrix = try Matrix.init(allocator, &buffer),
    }
    defer {
        switch (config.animation) {
            .none => {},
            .doom => doom.deinit(),
            .matrix => matrix.deinit(),
        }
    }
    const animate = config.animation != .none;
    const shutdown_key = try std.fmt.parseInt(u8, config.shutdown_key[1..], 10);
    const shutdown_len = try utils.strWidth(lang.shutdown);
    const restart_key = try std.fmt.parseInt(u8, config.restart_key[1..], 10);
    const restart_len = try utils.strWidth(lang.restart);
    const sleep_key = try std.fmt.parseInt(u8, config.sleep_key[1..], 10);
    var event: termbox.tb_event = undefined;
    var run = true;
    var update = true;
    var resolution_changed = false;
    var auth_fails: u64 = 0;
    // Switch to selected TTY if possible
    open_console_dev: {
        const fd = std.posix.open(config.console_dev, .{ .ACCMODE = .WRONLY }, 0) catch {
            try info_line.setText(lang.err_console_dev);
            break :open_console_dev;
        };
        defer std.posix.close(fd);
        _ = std.c.ioctl(fd, interop.VT_ACTIVATE, config.tty);
        _ = std.c.ioctl(fd, interop.VT_WAITACTIVE, config.tty);
    }
    while (run) {
        // If there's no input or there's an animation, a resolution change needs to be checked
        if (!update or config.animation != .none) {
            if (!update) std.time.sleep(std.time.ns_per_ms * 100);
            _ = termbox.tb_present(); // Required to update tb_width(), tb_height() and tb_cell_buffer()
            const width: u64 = @intCast(termbox.tb_width());
            const height: u64 = @intCast(termbox.tb_height());
            if (width != buffer.width) {
                buffer.width = width;
                resolution_changed = true;
            }
            if (height != buffer.height) {
                buffer.height = height;
                resolution_changed = true;
            }
            // If it did change, then update the cell buffer, reallocate the current animation's buffers, and force a draw update
            if (resolution_changed) {
                buffer.buffer = termbox.tb_cell_buffer();
                switch (config.animation) {
                    .none => {},
                    .doom => doom.realloc() catch {
                        try info_line.setText(lang.err_alloc);
                    },
                    .matrix => matrix.realloc() catch {
                        try info_line.setText(lang.err_alloc);
                    },
                }
                update = true;
            }
        }
        if (update) {
            // If the user entered a wrong password 10 times in a row, play a cascade animation, else update normally
            if (auth_fails < 10) {
                _ = termbox.tb_clear();
                switch (config.animation) {
                    .none => {},
                    .doom => doom.draw(),
                    .matrix => matrix.draw(),
                }
                if (config.bigclock and buffer.box_height + (bigclock.HEIGHT + 2) * 2 < buffer.height) draw_big_clock: {
                    const format = "%H:%M";
                    const xo = buffer.width / 2 - @min(buffer.width, (format.len * (bigclock.WIDTH + 1))) / 2;
                    const yo = (buffer.height - buffer.box_height) / 2 - bigclock.HEIGHT - 2;
                    var clock_buf: [format.len + 1:0]u8 = undefined;
                    const clock_str = interop.timeAsString(&clock_buf, format) catch {
                        break :draw_big_clock;
                    };
                    for (clock_str, 0..) |c, i| {
                        const clock_cell = bigclock.clockCell(animate, c, buffer.fg, buffer.bg);
                        bigclock.alphaBlit(buffer.buffer, xo + i * (bigclock.WIDTH + 1), yo, buffer.width, buffer.height, clock_cell);
                    }
                }
                buffer.drawBoxCenter(!config.hide_borders, config.blank_box);
                if (resolution_changed) {
                    const coordinates = buffer.calculateComponentCoordinates();
                    desktop.position(coordinates.x, coordinates.y + 2, coordinates.visible_length);
                    login.position(coordinates.x, coordinates.y + 4, coordinates.visible_length);
                    password.position(coordinates.x, coordinates.y + 6, coordinates.visible_length);
                    resolution_changed = false;
                }
                switch (active_input) {
                    .session => desktop.handle(null, insert_mode),
                    .login => login.handle(null, insert_mode) catch {
                        try info_line.setText(lang.err_alloc);
                    },
                    .password => password.handle(null, insert_mode) catch {
                        try info_line.setText(lang.err_alloc);
                    },
                }
                if (config.clock) |clock| draw_clock: {
                    var clock_buf: [32:0]u8 = undefined;
                    const clock_str = interop.timeAsString(&clock_buf, clock) catch {
                        break :draw_clock;
                    };
                    if (clock_str.len == 0) return error.FormattedTimeEmpty;
                    buffer.drawLabel(clock_str, buffer.width - @min(buffer.width, clock_str.len), 0);
                }
                const label_x = buffer.box_x + buffer.margin_box_h;
                const label_y = buffer.box_y + buffer.margin_box_v;
                buffer.drawLabel(lang.login, label_x, label_y + 4);
                buffer.drawLabel(lang.password, label_x, label_y + 6);
                info_line.draw(buffer);
                if (!config.hide_key_hints) {
                    var length: u64 = 0;
                    buffer.drawLabel(config.shutdown_key, length, 0);
                    length += config.shutdown_key.len + 1;
                    buffer.drawLabel(" ", length - 1, 0);
                    buffer.drawLabel(lang.shutdown, length, 0);
                    length += shutdown_len + 1;
                    buffer.drawLabel(config.restart_key, length, 0);
                    length += config.restart_key.len + 1;
                    buffer.drawLabel(" ", length - 1, 0);
                    buffer.drawLabel(lang.restart, length, 0);
                    length += restart_len + 1;
                    if (config.sleep_cmd != null) {
                        buffer.drawLabel(config.sleep_key, length, 0);
                        length += config.sleep_key.len + 1;
                        buffer.drawLabel(" ", length - 1, 0);
                        buffer.drawLabel(lang.sleep, length, 0);
                    }
                }
                if (config.box_title) |title| {
                    buffer.drawConfinedLabel(title, buffer.box_x, buffer.box_y - 1, buffer.box_width);
                }
                if (config.vi_mode) {
                    const label_txt = if (insert_mode) lang.insert else lang.normal;
                    buffer.drawLabel(label_txt, buffer.box_x, buffer.box_y + buffer.box_height);
                }
                draw_lock_state: {
                    const lock_state = interop.getLockState(config.console_dev) catch {
                        try info_line.setText(lang.err_console_dev);
                        break :draw_lock_state;
                    };
                    var lock_state_x = buffer.width - @min(buffer.width, lang.numlock.len);
                    const lock_state_y: u64 = if (config.clock != null) 1 else 0;
                    if (lock_state.numlock) buffer.drawLabel(lang.numlock, lock_state_x, lock_state_y);
                    if (lock_state_x >= lang.capslock.len + 1) {
                        lock_state_x -= lang.capslock.len + 1;
                        if (lock_state.capslock) buffer.drawLabel(lang.capslock, lock_state_x, lock_state_y);
                    }
                }
                desktop.draw();
                login.draw();
                password.drawMasked(config.asterisk);
            } else {
                std.time.sleep(std.time.ns_per_ms * 10);
                update = buffer.cascade();
                if (!update) {
                    std.time.sleep(std.time.ns_per_s * 7);
                    auth_fails = 0;
                }
            }
            _ = termbox.tb_present();
        }
        var timeout: i32 = -1;
        // Calculate the maximum timeout based on current animations, or the (big) clock. If there's none, we wait for the event indefinitely instead
        if (animate) {
            timeout = config.min_refresh_delta;
        } else if (config.bigclock and config.clock == null) {
            var tv: std.c.timeval = undefined;
            _ = std.c.gettimeofday(&tv, null);
            timeout = @intCast((60 - @rem(tv.tv_sec, 60)) * 1000 - @divTrunc(tv.tv_usec, 1000) + 1);
        } else if (config.clock != null or auth_fails >= 10) {
            var tv: std.c.timeval = undefined;
            _ = std.c.gettimeofday(&tv, null);
            timeout = @intCast(1000 - @divTrunc(tv.tv_usec, 1000) + 1);
        }
        const event_error = if (timeout == -1) termbox.tb_poll_event(&event) else termbox.tb_peek_event(&event, timeout);
        update = timeout != -1;
        if (event_error < 0 or event.type != termbox.TB_EVENT_KEY) continue;
        switch (event.key) {
            termbox.TB_KEY_ESC => {
                if (config.vi_mode and insert_mode) {
                    insert_mode = false;
                    update = true;
                }
            },
            termbox.TB_KEY_F12...termbox.TB_KEY_F1 => {
                const pressed_key = 0xFFFF - event.key + 1;
                if (pressed_key == shutdown_key) {
                    shutdown = true;
                    run = false;
                } else if (pressed_key == restart_key) {
                    restart = true;
                    run = false;
                } else if (pressed_key == sleep_key) {
                    if (config.sleep_cmd) |sleep_cmd| {
                        var sleep = std.process.Child.init(&[_][]const u8{ "/bin/sh", "-c", sleep_cmd }, allocator);
                        _ = sleep.spawnAndWait() catch .{};
                    }
                }
            },
            termbox.TB_KEY_CTRL_C => run = false,
            termbox.TB_KEY_CTRL_U => {
                if (active_input == .login) {
                    login.clear();
                    update = true;
                } else if (active_input == .password) {
                    password.clear();
                    update = true;
                }
            },
            termbox.TB_KEY_CTRL_K, termbox.TB_KEY_ARROW_UP => {
                active_input = switch (active_input) {
                    .session, .login => .session,
                    .password => .login,
                };
                update = true;
            },
            termbox.TB_KEY_CTRL_J, termbox.TB_KEY_ARROW_DOWN => {
                active_input = switch (active_input) {
                    .session => .login,
                    .login, .password => .password,
                };
                update = true;
            },
            termbox.TB_KEY_TAB => {
                active_input = switch (active_input) {
                    .session => .login,
                    .login => .password,
                    .password => .session,
                };
                update = true;
            },
            termbox.TB_KEY_BACK_TAB => {
                active_input = switch (active_input) {
                    .session => .password,
                    .login => .session,
                    .password => .login,
                };
                update = true;
            },
            termbox.TB_KEY_ENTER => {
                if (config.save) save_last_settings: {
                    var file = std.fs.cwd().createFile(save_path, .{}) catch break :save_last_settings;
                    defer file.close();
                    const save_data = Save{
                        .user = login.text.items,
                        .session_index = desktop.current,
                    };
                    ini.writeFromStruct(save_data, file.writer(), null, true, .{}) catch break :save_last_settings;
                }
                var shared_err = try SharedError.init();
                defer shared_err.deinit();
                {
                    const login_text = try allocator.dupeZ(u8, login.text.items);
                    defer allocator.free(login_text);
                    const password_text = try allocator.dupeZ(u8, password.text.items);
                    defer allocator.free(password_text);
                    try info_line.setText(lang.authenticating);
                    InfoLine.clearRendered(allocator, buffer) catch {};
                    info_line.draw(buffer);
                    _ = termbox.tb_present();
                    session_pid = try std.posix.fork();
                    if (session_pid == 0) {
                        const current_environment = desktop.environments.items[desktop.current];
                        auth.authenticate(config, current_environment, login_text, password_text) catch |err| {
                            shared_err.writeError(err);
                            std.process.exit(1);
                        };
                        std.process.exit(0);
                    }
                    _ = std.posix.waitpid(session_pid, 0);
                    session_pid = -1;
                }
                const auth_err = shared_err.readError();
                if (auth_err) |err| {
                    auth_fails += 1;
                    active_input = .password;
                    try info_line.setText(getAuthErrorMsg(err, lang));
                    if (config.clear_password or err != error.PamAuthError) password.clear();
                } else {
                    password.clear();
                    try info_line.setText(lang.logout);
                }
                try std.posix.tcsetattr(std.posix.STDIN_FILENO, .FLUSH, tb_termios);
                if (auth_fails < 10) {
                    _ = termbox.tb_clear();
                    _ = termbox.tb_present();
                }
                update = true;
                var restore_cursor = std.process.Child.init(&[_][]const u8{ "/bin/sh", "-c", config.term_restore_cursor_cmd }, allocator);
                _ = restore_cursor.spawnAndWait() catch .{};
            },
            else => {
                if (!insert_mode) {
                    switch (event.ch) {
                        'k' => {
                            active_input = switch (active_input) {
                                .session, .login => .session,
                                .password => .login,
                            };
                            update = true;
                            continue;
                        },
                        'j' => {
                            active_input = switch (active_input) {
                                .session => .login,
                                .login, .password => .password,
                            };
                            update = true;
                            continue;
                        },
                        'i' => {
                            insert_mode = true;
                            update = true;
                            continue;
                        },
                        else => {},
                    }
                }
                switch (active_input) {
                    .session => desktop.handle(&event, insert_mode),
                    .login => login.handle(&event, insert_mode) catch {
                        try info_line.setText(lang.err_alloc);
                    },
                    .password => password.handle(&event, insert_mode) catch {
                        try info_line.setText(lang.err_alloc);
                    },
                }
                update = true;
            },
        }
    }
 }
 fn getAuthErrorMsg(err: anyerror, lang: Lang) []const u8 {
    return switch (err) {
        error.GetPasswordNameFailed => lang.err_pwnam,
        error.GetEnvListFailed => lang.err_envlist,
        error.XauthFailed => lang.err_xauth,
        error.McookieFailed => lang.err_mcookie,
        error.XcbConnectionFailed => lang.err_xcb_conn,
        error.GroupInitializationFailed => lang.err_user_init,
        error.SetUserGidFailed => lang.err_user_gid,
        error.SetUserUidFailed => lang.err_user_uid,
        error.ChangeDirectoryFailed => lang.err_perm_dir,
        error.SetPathFailed => lang.err_path,
        error.PamAccountExpired => lang.err_pam_acct_expired,
        error.PamAuthError => lang.err_pam_auth,
        error.PamAuthInfoUnavailable => lang.err_pam_authinfo_unavail,
        error.PamBufferError => lang.err_pam_buf,
        error.PamCredentialsError => lang.err_pam_cred_err,
        error.PamCredentialsExpired => lang.err_pam_cred_expired,
        error.PamCredentialsInsufficient => lang.err_pam_cred_insufficient,
        error.PamCredentialsUnavailable => lang.err_pam_cred_unavail,
        error.PamMaximumTries => lang.err_pam_maxtries,
        error.PamNewAuthTokenRequired => lang.err_pam_authok_reqd,
        error.PamPermissionDenied => lang.err_pam_perm_denied,
        error.PamSessionError => lang.err_pam_session,
        error.PamSystemError => lang.err_pam_sys,
        error.PamUserUnknown => lang.err_pam_user_unknown,
        error.PamAbort => lang.err_pam_abort,
        else => lang.err_unknown,
    };
 }
--- a/src/tui/TerminalBuffer.zig
+++ b/src/tui/TerminalBuffer.zig
@@ -1,188 +0,0 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const interop = @import("../interop.zig");
 const utils = @import("utils.zig");
 const Config = @import("../config/Config.zig");
 const Random = std.Random;
 const termbox = interop.termbox;
 const TerminalBuffer = @This();
 random: Random,
 width: u64,
 height: u64,
 buffer: [*]termbox.tb_cell,
 fg: u8,
 bg: u8,
 border_fg: u8,
 box_chars: struct {
    left_up: u32,
    left_down: u32,
    right_up: u32,
    right_down: u32,
    top: u32,
    bottom: u32,
    left: u32,
    right: u32,
 },
 labels_max_length: u64,
 box_x: u64,
 box_y: u64,
 box_width: u64,
 box_height: u64,
 margin_box_v: u8,
 margin_box_h: u8,
 pub fn init(config: Config, labels_max_length: u64, random: Random) TerminalBuffer {
    return .{
        .random = random,
        .width = @intCast(termbox.tb_width()),
        .height = @intCast(termbox.tb_height()),
        .buffer = termbox.tb_cell_buffer(),
        .fg = config.fg,
        .bg = config.bg,
        .border_fg = config.border_fg,
        .box_chars = if (builtin.os.tag == .linux or builtin.os.tag.isBSD()) .{
            .left_up = 0x250C,
            .left_down = 0x2514,
            .right_up = 0x2510,
            .right_down = 0x2518,
            .top = 0x2500,
            .bottom = 0x2500,
            .left = 0x2502,
            .right = 0x2502,
        } else .{
            .left_up = '+',
            .left_down = '+',
            .right_up = '+',
            .right_down = '+',
            .top = '-',
            .bottom = '-',
            .left = '|',
            .right = '|',
        },
        .labels_max_length = labels_max_length,
        .box_x = 0,
        .box_y = 0,
        .box_width = (2 * config.margin_box_h) + config.input_len + 1 + labels_max_length,
        .box_height = 7 + (2 * config.margin_box_v),
        .margin_box_v = config.margin_box_v,
        .margin_box_h = config.margin_box_h,
    };
 }
 pub fn cascade(self: TerminalBuffer) bool {
    var changes = false;
    var y = self.height - 2;
    while (y > 0) : (y -= 1) {
        for (0..self.width) |x| {
            const c: u8 = @truncate(self.buffer[(y - 1) * self.width + x].ch);
            if (std.ascii.isWhitespace(c)) continue;
            const c_under: u8 = @truncate(self.buffer[y * self.width + x].ch);
            if (!std.ascii.isWhitespace(c_under)) continue;
            changes = true;
            if ((self.random.int(u16) % 10) > 7) continue;
            self.buffer[y * self.width + x] = self.buffer[(y - 1) * self.width + x];
            self.buffer[(y - 1) * self.width + x].ch = ' ';
        }
    }
    return changes;
 }
 pub fn drawBoxCenter(self: *TerminalBuffer, show_borders: bool, blank_box: bool) void {
    if (self.width < 2 or self.height < 2) return;
    const x1 = (self.width - @min(self.width - 2, self.box_width)) / 2;
    const y1 = (self.height - @min(self.height - 2, self.box_height)) / 2;
    const x2 = (self.width + @min(self.width, self.box_width)) / 2;
    const y2 = (self.height + @min(self.height, self.box_height)) / 2;
    self.box_x = x1;
    self.box_y = y1;
    if (show_borders) {
        _ = termbox.tb_set_cell(@intCast(x1 - 1), @intCast(y1 - 1), self.box_chars.left_up, self.border_fg, self.bg);
        _ = termbox.tb_set_cell(@intCast(x2), @intCast(y1 - 1), self.box_chars.right_up, self.border_fg, self.bg);
        _ = termbox.tb_set_cell(@intCast(x1 - 1), @intCast(y2), self.box_chars.left_down, self.border_fg, self.bg);
        _ = termbox.tb_set_cell(@intCast(x2), @intCast(y2), self.box_chars.right_down, self.border_fg, self.bg);
        var c1 = utils.initCell(self.box_chars.top, self.border_fg, self.bg);
        var c2 = utils.initCell(self.box_chars.bottom, self.border_fg, self.bg);
        for (0..self.box_width) |i| {
            _ = utils.putCell(@intCast(x1 + i), @intCast(y1 - 1), &c1);
            _ = utils.putCell(@intCast(x1 + i), @intCast(y2), &c2);
        }
        c1.ch = self.box_chars.left;
        c2.ch = self.box_chars.right;
        for (0..self.box_height) |i| {
            _ = utils.putCell(@intCast(x1 - 1), @intCast(y1 + i), &c1);
            _ = utils.putCell(@intCast(x2), @intCast(y1 + i), &c2);
        }
    }
    if (blank_box) {
        const blank = utils.initCell(' ', self.fg, self.bg);
        for (0..self.box_height) |y| {
            for (0..self.box_width) |x| {
                _ = utils.putCell(@intCast(x1 + x), @intCast(y1 + y), &blank);
            }
        }
    }
 }
 pub fn calculateComponentCoordinates(self: TerminalBuffer) struct {
    x: u64,
    y: u64,
    visible_length: u64,
 } {
    const x = self.box_x + self.margin_box_h + self.labels_max_length + 1;
    const y = self.box_y + self.margin_box_v;
    const visible_length = self.box_x + self.box_width - self.margin_box_h - x;
    return .{
        .x = x,
        .y = y,
        .visible_length = visible_length,
    };
 }
 pub fn drawLabel(self: TerminalBuffer, text: []const u8, x: u64, y: u64) void {
    const yc: c_int = @intCast(y);
    const utf8view = std.unicode.Utf8View.init(text) catch return;
    var utf8 = utf8view.iterator();
    var i = x;
    while (utf8.nextCodepoint()) |codepoint| : (i += 1) {
        _ = termbox.tb_set_cell(@intCast(i), yc, codepoint, self.fg, self.bg);
    }
 }
 pub fn drawConfinedLabel(self: TerminalBuffer, text: []const u8, x: u64, y: u64, max_length: u64) void {
    const yc: c_int = @intCast(y);
    const utf8view = std.unicode.Utf8View.init(text) catch return;
    var utf8 = utf8view.iterator();
    var i: usize = 0;
    while (utf8.nextCodepoint()) |codepoint| : (i += 1) {
        if (i >= max_length) break;
        _ = termbox.tb_set_cell(@intCast(i + x), yc, codepoint, self.fg, self.bg);
    }
 }
 pub fn drawCharMultiple(self: TerminalBuffer, char: u8, x: u64, y: u64, length: u64) void {
    const yc: c_int = @intCast(y);
    const cell = utils.initCell(char, self.fg, self.bg);
    for (0..length) |xx| _ = utils.putCell(@intCast(x + xx), yc, &cell);
 }
--- a/src/tui/components/Desktop.zig
+++ b/src/tui/components/Desktop.zig
@@ -1,223 +0,0 @@
 const std = @import("std");
 const enums = @import("../../enums.zig");
 const interop = @import("../../interop.zig");
 const TerminalBuffer = @import("../TerminalBuffer.zig");
 const Ini = @import("zigini").Ini;
 const Lang = @import("../../config/Lang.zig");
 const Allocator = std.mem.Allocator;
 const EnvironmentList = std.ArrayList(Environment);
 const DisplayServer = enums.DisplayServer;
 const termbox = interop.termbox;
 const Desktop = @This();
 pub const Environment = struct {
    entry_ini: ?Ini(Entry) = null,
    name: [:0]const u8 = "",
    xdg_session_desktop: [:0]const u8 = "",
    xdg_desktop_names: ?[:0]const u8 = "",
    cmd: []const u8 = "",
    specifier: []const u8 = "",
    display_server: DisplayServer = .wayland,
 };
 const DesktopEntry = struct {
    Exec: []const u8 = "",
    Name: [:0]const u8 = "",
    DesktopNames: ?[]const u8 = null,
 };
 pub const Entry = struct { @"Desktop Entry": DesktopEntry = DesktopEntry{} };
 allocator: Allocator,
 buffer: *TerminalBuffer,
 environments: EnvironmentList,
 current: u64,
 visible_length: u64,
 x: u64,
 y: u64,
 lang: Lang,
 pub fn init(allocator: Allocator, buffer: *TerminalBuffer, max_length: u64, lang: Lang) !Desktop {
    return .{
        .allocator = allocator,
        .buffer = buffer,
        .environments = try EnvironmentList.initCapacity(allocator, max_length),
        .current = 0,
        .visible_length = 0,
        .x = 0,
        .y = 0,
        .lang = lang,
    };
 }
 pub fn deinit(self: Desktop) void {
    for (self.environments.items) |*environment| {
        if (environment.entry_ini) |*entry_ini| entry_ini.deinit();
        if (environment.xdg_desktop_names) |desktop_name| self.allocator.free(desktop_name);
        self.allocator.free(environment.xdg_session_desktop);
    }
    self.environments.deinit();
 }
 pub fn position(self: *Desktop, x: u64, y: u64, visible_length: u64) void {
    self.x = x;
    self.y = y;
    self.visible_length = visible_length;
 }
 pub fn addEnvironment(self: *Desktop, entry: DesktopEntry, xdg_session_desktop: []const u8, display_server: DisplayServer) !void {
    var xdg_desktop_names: ?[:0]const u8 = null;
    if (entry.DesktopNames) |desktop_names| {
        const desktop_names_z = try self.allocator.dupeZ(u8, desktop_names);
        for (desktop_names_z) |*c| {
            if (c.* == ';') c.* = ':';
        }
        xdg_desktop_names = desktop_names_z;
    }
    errdefer {
        if (xdg_desktop_names) |desktop_names| self.allocator.free(desktop_names);
    }
    const session_desktop = try self.allocator.dupeZ(u8, xdg_session_desktop);
    errdefer self.allocator.free(session_desktop);
    try self.environments.append(.{
        .entry_ini = null,
        .name = entry.Name,
        .xdg_session_desktop = session_desktop,
        .xdg_desktop_names = xdg_desktop_names,
        .cmd = entry.Exec,
        .specifier = switch (display_server) {
            .wayland => self.lang.wayland,
            .x11 => self.lang.x11,
            else => self.lang.other,
        },
        .display_server = display_server,
    });
    self.current = self.environments.items.len - 1;
 }
 pub fn addEnvironmentWithIni(self: *Desktop, entry_ini: Ini(Entry), xdg_session_desktop: []const u8, display_server: DisplayServer) !void {
    const entry = entry_ini.data.@"Desktop Entry";
    var xdg_desktop_names: ?[:0]const u8 = null;
    if (entry.DesktopNames) |desktop_names| {
        const desktop_names_z = try self.allocator.dupeZ(u8, desktop_names);
        for (desktop_names_z) |*c| {
            if (c.* == ';') c.* = ':';
        }
        xdg_desktop_names = desktop_names_z;
    }
    errdefer {
        if (xdg_desktop_names) |desktop_names| self.allocator.free(desktop_names);
    }
    const session_desktop = try self.allocator.dupeZ(u8, xdg_session_desktop);
    errdefer self.allocator.free(session_desktop);
    try self.environments.append(.{
        .entry_ini = entry_ini,
        .name = entry.Name,
        .xdg_session_desktop = session_desktop,
        .xdg_desktop_names = xdg_desktop_names,
        .cmd = entry.Exec,
        .specifier = switch (display_server) {
            .wayland => self.lang.wayland,
            .x11 => self.lang.x11,
            else => self.lang.other,
        },
        .display_server = display_server,
    });
    self.current = self.environments.items.len - 1;
 }
 pub fn crawl(self: *Desktop, path: []const u8, display_server: DisplayServer) !void {
    var iterable_directory = std.fs.openDirAbsolute(path, .{ .iterate = true }) catch return;
    defer iterable_directory.close();
    var iterator = iterable_directory.iterate();
    while (try iterator.next()) |item| {
        if (!std.mem.eql(u8, std.fs.path.extension(item.name), ".desktop")) continue;
        const entry_path = try std.fmt.allocPrint(self.allocator, "{s}/{s}", .{ path, item.name });
        defer self.allocator.free(entry_path);
        var entry_ini = Ini(Entry).init(self.allocator);
        _ = try entry_ini.readFileToStruct(entry_path, "#", null);
        errdefer entry_ini.deinit();
        var xdg_session_desktop: []const u8 = undefined;
        const maybe_desktop_names = entry_ini.data.@"Desktop Entry".DesktopNames;
        if (maybe_desktop_names) |desktop_names| {
            xdg_session_desktop = std.mem.sliceTo(desktop_names, ';');
        } else {
            // if DesktopNames is empty, we'll take the name of the session file
            xdg_session_desktop = std.fs.path.stem(item.name);
        }
        try self.addEnvironmentWithIni(entry_ini, xdg_session_desktop, display_server);
    }
 }
 pub fn handle(self: *Desktop, maybe_event: ?*termbox.tb_event, insert_mode: bool) void {
    if (maybe_event) |event| blk: {
        if (event.type != termbox.TB_EVENT_KEY) break :blk;
        switch (event.key) {
            termbox.TB_KEY_ARROW_LEFT, termbox.TB_KEY_CTRL_H => self.goLeft(),
            termbox.TB_KEY_ARROW_RIGHT, termbox.TB_KEY_CTRL_L => self.goRight(),
            else => {
                if (!insert_mode) {
                    switch (event.ch) {
                        'h' => self.goLeft(),
                        'l' => self.goRight(),
                        else => {},
                    }
                }
            },
        }
    }
    _ = termbox.tb_set_cursor(@intCast(self.x + 2), @intCast(self.y));
 }
 pub fn draw(self: Desktop) void {
    const environment = self.environments.items[self.current];
    const length = @min(environment.name.len, self.visible_length - 3);
    if (length == 0) return;
    const x = self.buffer.box_x + self.buffer.margin_box_h;
    const y = self.buffer.box_y + self.buffer.margin_box_v + 2;
    self.buffer.drawLabel(environment.specifier, x, y);
    _ = termbox.tb_set_cell(@intCast(self.x), @intCast(self.y), '<', self.buffer.fg, self.buffer.bg);
    _ = termbox.tb_set_cell(@intCast(self.x + self.visible_length - 1), @intCast(self.y), '>', self.buffer.fg, self.buffer.bg);
    self.buffer.drawLabel(environment.name, self.x + 2, self.y);
 }
 fn goLeft(self: *Desktop) void {
    if (self.current == 0) {
        self.current = self.environments.items.len - 1;
        return;
    }
    self.current -= 1;
 }
 fn goRight(self: *Desktop) void {
    if (self.current == self.environments.items.len - 1) {
        self.current = 0;
        return;
    }
    self.current += 1;
 }
--- a/src/tui/components/InfoLine.zig
+++ b/src/tui/components/InfoLine.zig
@@ -1,33 +0,0 @@
 const std = @import("std");
 const utils = @import("../utils.zig");
 const TerminalBuffer = @import("../TerminalBuffer.zig");
 const InfoLine = @This();
 text: []const u8 = "",
 width: u8 = 0,
 pub fn setText(self: *InfoLine, text: []const u8) !void {
    self.width = if (text.len > 0) try utils.strWidth(text) else 0;
    self.text = text;
 }
 pub fn draw(self: InfoLine, buffer: TerminalBuffer) void {
    if (self.width > 0 and buffer.box_width > self.width) {
        const label_y = buffer.box_y + buffer.margin_box_v;
        const x = buffer.box_x + ((buffer.box_width - self.width) / 2);
        buffer.drawLabel(self.text, x, label_y);
    }
 }
 pub fn clearRendered(allocator: std.mem.Allocator, buffer: TerminalBuffer) !void {
    // draw over the area
    const y = buffer.box_y + buffer.margin_box_v;
    const spaces = try allocator.alloc(u8, buffer.box_width);
    defer allocator.free(spaces);
    @memset(spaces, ' ');
    buffer.drawLabel(spaces, buffer.box_x, y);
 }
--- a/src/tui/components/Text.zig
+++ b/src/tui/components/Text.zig
@@ -1,149 +0,0 @@
 const std = @import("std");
 const interop = @import("../../interop.zig");
 const TerminalBuffer = @import("../TerminalBuffer.zig");
 const utils = @import("../utils.zig");
 const Allocator = std.mem.Allocator;
 const DynamicString = std.ArrayList(u8);
 const termbox = interop.termbox;
 const Text = @This();
 allocator: Allocator,
 buffer: *TerminalBuffer,
 text: DynamicString,
 end: u64,
 cursor: u64,
 visible_start: u64,
 visible_length: u64,
 x: u64,
 y: u64,
 pub fn init(allocator: Allocator, buffer: *TerminalBuffer, max_length: u64) !Text {
    const text = try DynamicString.initCapacity(allocator, max_length);
    return .{
        .allocator = allocator,
        .buffer = buffer,
        .text = text,
        .end = 0,
        .cursor = 0,
        .visible_start = 0,
        .visible_length = 0,
        .x = 0,
        .y = 0,
    };
 }
 pub fn deinit(self: Text) void {
    self.text.deinit();
 }
 pub fn position(self: *Text, x: u64, y: u64, visible_length: u64) void {
    self.x = x;
    self.y = y;
    self.visible_length = visible_length;
 }
 pub fn handle(self: *Text, maybe_event: ?*termbox.tb_event, insert_mode: bool) !void {
    if (maybe_event) |event| blk: {
        if (event.type != termbox.TB_EVENT_KEY) break :blk;
        switch (event.key) {
            termbox.TB_KEY_ARROW_LEFT => self.goLeft(),
            termbox.TB_KEY_ARROW_RIGHT => self.goRight(),
            termbox.TB_KEY_DELETE => self.delete(),
            termbox.TB_KEY_BACKSPACE, termbox.TB_KEY_BACKSPACE2 => {
                if (insert_mode) {
                    self.backspace();
                } else {
                    self.goLeft();
                }
            },
            termbox.TB_KEY_SPACE => try self.write(' '),
            else => {
                if (event.ch > 31 and event.ch < 127) {
                    if (insert_mode) {
                        try self.write(@intCast(event.ch));
                    } else {
                        switch (event.ch) {
                            'h' => self.goLeft(),
                            'l' => self.goRight(),
                            else => {},
                        }
                    }
                }
            },
        }
    }
    _ = termbox.tb_set_cursor(@intCast(self.x + (self.cursor - self.visible_start)), @intCast(self.y));
 }
 pub fn draw(self: Text) void {
    const length = @min(self.text.items.len, self.visible_length);
    if (length == 0) return;
    const visible_slice = vs: {
        if (self.text.items.len > self.visible_length and self.cursor < self.text.items.len) {
            break :vs self.text.items[self.visible_start..(self.visible_length + self.visible_start)];
        } else {
            break :vs self.text.items[self.visible_start..];
        }
    };
    self.buffer.drawLabel(visible_slice, self.x, self.y);
 }
 pub fn drawMasked(self: Text, mask: u8) void {
    const length = @min(self.text.items.len, self.visible_length - 1);
    if (length == 0) return;
    self.buffer.drawCharMultiple(mask, self.x, self.y, length);
 }
 pub fn clear(self: *Text) void {
    self.text.clearRetainingCapacity();
    self.end = 0;
    self.cursor = 0;
    self.visible_start = 0;
 }
 fn goLeft(self: *Text) void {
    if (self.cursor == 0) return;
    if (self.visible_start > 0) self.visible_start -= 1;
    self.cursor -= 1;
 }
 fn goRight(self: *Text) void {
    if (self.cursor >= self.end) return;
    if (self.cursor - self.visible_start == self.visible_length - 1) self.visible_start += 1;
    self.cursor += 1;
 }
 fn delete(self: *Text) void {
    if (self.cursor >= self.end) return;
    _ = self.text.orderedRemove(self.cursor);
    self.end -= 1;
 }
 fn backspace(self: *Text) void {
    if (self.cursor == 0) return;
    self.goLeft();
    self.delete();
 }
 fn write(self: *Text, char: u8) !void {
    if (char == 0) return;
    try self.text.insert(self.cursor, char);
    self.end += 1;
    self.goRight();
 }
--- a/src/tui/utils.zig
+++ b/src/tui/utils.zig
@@ -1,26 +0,0 @@
 const std = @import("std");
 const interop = @import("../interop.zig");
 const termbox = interop.termbox;
 pub fn initCell(ch: u32, fg: u16, bg: u16) termbox.tb_cell {
    return .{
        .ch = ch,
        .fg = fg,
        .bg = bg,
    };
 }
 pub fn putCell(x: i32, y: i32, cell: *const termbox.tb_cell) c_int {
    return termbox.tb_set_cell(x, y, cell.ch, cell.fg, cell.bg);
 }
 // Every codepoint is assumed to have a width of 1.
 // Since ly should be running in a tty, this should be fine.
 pub fn strWidth(str: []const u8) !u8 {
    const utf8view = try std.unicode.Utf8View.init(str);
    var utf8 = utf8view.iterator();
    var i: u8 = 0;
    while (utf8.nextCodepoint()) |_| i += 1;
    return i;
 }
--- a/src/utils.c
+++ b/src/utils.c
@@ -0,0 +1,276 @@
 #include "configator.h"
 #include "dragonfail.h"
 #include "inputs.h"
 #include "config.h"
 #include "utils.h"
 #include <dirent.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ioctl.h>
 #include <unistd.h>
 #if defined(__DragonFly__) || defined(__FreeBSD__)
 	#include <sys/consio.h>
 #else // linux
 	#include <linux/vt.h>
 #endif
 void desktop_crawl(
 	struct desktop* target,
 	char* sessions,
 	enum display_server server)
 {
 	DIR* dir;
 	struct dirent* dir_info;
 	int ok;
 	ok = access(sessions, F_OK);
 	if (ok == -1)
 	{
 		dgn_throw(DGN_XSESSIONS_DIR);
 		return;
 	}
 	dir = opendir(sessions);
 	if (dir == NULL)
 	{
 		dgn_throw(DGN_XSESSIONS_OPEN);
 		return;
 	}
 	char* name = NULL;
 	char* exec = NULL;
 	struct configator_param map_desktop[] =
 	{
 		{"Exec", &exec, config_handle_str},
 		{"Name", &name, config_handle_str},
 	};
 	struct configator_param* map[] =
 	{
 		NULL,
 		map_desktop,
 	};
 	struct configator_param sections[] =	
 	{
 		{"Desktop Entry", NULL, NULL},
 	};
 	uint16_t map_len[] = {0, 2};
 	uint16_t sections_len = 1;
 	struct configator desktop_config;
 	desktop_config.map = map;
 	desktop_config.map_len = map_len;
 	desktop_config.sections = sections;
 	desktop_config.sections_len = sections_len;
 #if defined(NAME_MAX)
 	char path[NAME_MAX];
 #elif defined(_POSIX_PATH_MAX)
 	char path[_POSIX_PATH_MAX];
 #else
 	char path[1024];
 #endif
 	dir_info = readdir(dir);
 	while (dir_info != NULL)
 	{
 		if ((dir_info->d_name)[0] == '.')
 		{
 			dir_info = readdir(dir);
 			continue;
 		}
 		snprintf(path, (sizeof (path)) - 1, "%s/", sessions);
 		strncat(path, dir_info->d_name, (sizeof (path)) - 1);
 		configator(&desktop_config, path);
 		// if these are wayland sessions, add " (Wayland)" to their names,
 		// as long as their names don't already contain that string
 		if (server == DS_WAYLAND && config.wayland_specifier)
 		{
 			const char wayland_specifier[] = " (Wayland)";
 			if (strstr(name, wayland_specifier) == NULL)
 			{
 				name = realloc(name, (strlen(name) + sizeof(wayland_specifier) + 1));
 				// using strcat is safe because the string is constant
 				strcat(name, wayland_specifier);
 			}
 		}
 		if ((name != NULL) && (exec != NULL))
 		{
 			input_desktop_add(target, name, exec, server);
 		}
 		name = NULL;
 		exec = NULL;
 		dir_info = readdir(dir);
 	}
 	closedir(dir);
 }
 void desktop_load(struct desktop* target)
 {
 	// we don't care about desktop environments presence
 	// because the fallback shell is always available
 	// so we just dismiss any "throw" for now
 	int err = 0;
 	desktop_crawl(target, config.waylandsessions, DS_WAYLAND);
 	if (dgn_catch())
 	{
 		++err;
 		dgn_reset();
 	}
 	desktop_crawl(target, config.xsessions, DS_XORG);
 	if (dgn_catch())
 	{
 		++err;
 		dgn_reset();
 	}
 }
 static char* hostname_backup = NULL;
 void hostname(char** out)
 {
 	if (hostname_backup != NULL)
 	{
 		*out = hostname_backup;
 		return;
 	}
 	int maxlen = sysconf(_SC_HOST_NAME_MAX);
 	if (maxlen < 0)
 	{
 		maxlen = _POSIX_HOST_NAME_MAX;
 	}
 	hostname_backup = malloc(maxlen + 1);
 	if (hostname_backup == NULL)
 	{
 		dgn_throw(DGN_ALLOC);
 		return;
 	}
 	if (gethostname(hostname_backup, maxlen) < 0)
 	{
 		dgn_throw(DGN_HOSTNAME);
 		return;
 	}
 	hostname_backup[maxlen] = '\0';
 	*out = hostname_backup;
 }
 void free_hostname()
 {
 	free(hostname_backup);
 }
 void switch_tty(struct term_buf* buf)
 {
 	FILE* console = fopen(config.console_dev, "w");
 	if (console == NULL)
 	{
 		buf->info_line = lang.err_console_dev;
 		return;
 	}
 	int fd = fileno(console);
 	ioctl(fd, VT_ACTIVATE, config.tty);
 	ioctl(fd, VT_WAITACTIVE, config.tty);
 	fclose(console);
 }
 void save(struct desktop* desktop, struct text* login)
 {
 	if (config.save)
 	{
 		FILE* fp = fopen(config.save_file, "wb+");
 		if (fp != NULL)
 		{
 			fprintf(fp, "%s\n%d", login->text, desktop->cur);
 			fclose(fp);
 		}
 	}
 }
 void load(struct desktop* desktop, struct text* login)
 {
 	if (!config.load)
 	{
 		return;
 	}
 	FILE* fp = fopen(config.save_file, "rb");
 	if (fp == NULL)
 	{
 		return;
 	}
 	char* line = malloc(config.max_login_len + 1);
 	if (line == NULL)
 	{
 		fclose(fp);
 		return;
 	}
 	if (fgets(line, config.max_login_len + 1, fp))
 	{
 		int len = strlen(line);
 		strncpy(login->text, line, login->len);
 		if (len == 0)
 		{
 			login->end = login->text;
 		}
 		else
 		{
 			login->end = login->text + len - 1;
 			login->text[len - 1] = '\0';
 		}
 	}
 	else
 	{
 		fclose(fp);
 		free(line);
 		return;
 	}
 	if (fgets(line, config.max_login_len + 1, fp))
 	{
 		int saved_cur = abs(atoi(line));
 		if (saved_cur < desktop->len)
 		{
 			desktop->cur = saved_cur;
 		}
 	}
 	fclose(fp);
 	free(line);
 }
--- a/src/utils.h
+++ b/src/utils.h
@@ -0,0 +1,15 @@
 #ifndef H_LY_UTILS
 #define H_LY_UTILS
 #include "draw.h"
 #include "inputs.h"
 #include "config.h"
 void desktop_load(struct desktop* target);
 void hostname(char** out);
 void free_hostname();
 void switch_tty(struct term_buf* buf);
 void save(struct desktop* desktop, struct text* login);
 void load(struct desktop* desktop, struct text* login);
 #endif
--- a/sub/argoat
+++ b/sub/argoat
--- a/sub/configator
+++ b/sub/configator
--- a/sub/ctypes
+++ b/sub/ctypes
--- a/sub/dragonfail
+++ b/sub/dragonfail
--- a/sub/termbox_next
+++ b/sub/termbox_next
Author	SHA1	Message	Date
Leon Grünewald	271b4f8898	Add more files for labels	2021-02-14 14:59:59 +01:00
Leon Grünewald	552d533435	Try to fix path	2021-02-14 14:39:48 +01:00
Leon Grünewald	9d774d93c5	Add name to install	2021-02-14 14:10:04 +01:00
Leon Grünewald	90f18e9b34	We can't relabel nonexistant files anyway	2021-02-14 13:51:04 +01:00
Leon Grünewald	ccb9dfabc5	Move package somewhere else for install	2021-02-14 13:48:51 +01:00
Leon Grünewald	4ba42400ce	Use install instead of cp 1	2021-02-11 22:50:10 +01:00
Leon Grünewald	b336b70605	Remove versioning on git clone	2021-02-10 01:52:38 +01:00
Leon Grünewald	9c70ff5576	Add selinux policy tools to needed packages	2021-02-10 01:47:30 +01:00
Leon Grünewald	ec230541f3	Use make selinux macros	2021-02-10 01:46:15 +01:00
Leon Grünewald	d2fcb2e87d	Rename target	2021-02-10 01:37:52 +01:00
Leon Grünewald	96a556a345	Move the pp file into the right folder	2021-02-10 01:32:09 +01:00
Leon Grünewald	f79330cda3	Add installselinux to spec.rpkg	2021-02-10 01:23:03 +01:00
Leon Grünewald	3deedba040	WIP SELinux	2021-02-10 01:21:16 +01:00
Leon Grünewald	dfe918358e	Add gcc	2021-02-08 03:51:05 +01:00
Leon Grünewald	cd738eafa7	Actually push git before trying to build	2021-02-08 03:46:08 +01:00
Leon Grünewald	289624bc88	Test src stuff	2021-02-08 03:35:45 +01:00
Leon Grünewald	7d4b25fc70	Dont remove spec file	2021-02-08 03:25:55 +01:00
Leon Grünewald	b8b31386e1	move to rpkg again but this time remove setup	2021-02-08 03:06:01 +01:00
Leon Grünewald	a14e6b5224	Just copy everything from github at that point	2021-02-08 02:54:25 +01:00
Leon Grünewald	16922531e2	cd to spec first	2021-02-08 02:34:24 +01:00
Leon Grünewald	5c04c996d5	This makes some more sense now	2021-02-08 02:19:24 +01:00
Leon Grünewald	a7dedbab1b	Just the rpmbuild	2021-02-08 01:52:05 +01:00
Leon Grünewald	1926901eda	Fix it up	2021-02-08 01:47:01 +01:00
Leon Grünewald	43a40faf79	Build Requires make	2021-02-08 00:58:17 +01:00
Leon Grünewald	974aca51cb	Turn into ly.spec.rpkg	2021-02-08 00:33:35 +01:00
Leon Grünewald	6ac03ab27e	Add basic spec file and selinux module source	2021-02-08 00:13:19 +01:00
		`@@ -0,0 +1 @@`
							`/usr/bin/ly -- gen_context(system_u:object_r:ly_exec_t,s0)`
		`@@ -1,2 +0,0 @@`
			`user: ?[]const u8 = null,`
			`session_index: ?u64 = null,`