121 files changed, 14617 insertions, 0 deletions

diff --git a/lib/python/kle2xy.py b/lib/python/kle2xy.py
new file mode 100644
index 0000000000..608d1b9809
--- /dev/null
+++ b/lib/python/kle2xy.py
@@ -0,0 +1,126 @@
+""" Original code from https://github.com/skullydazed/kle2xy
+"""
+
+import hjson
+from decimal import Decimal
+
+
+class KLE2xy(list):
+    """Abstract interface for interacting with a KLE layout.
+    """
+    def __init__(self, layout=None, name='', invert_y=True):
+        super(KLE2xy, self).__init__()
+
+        self.name = name
+        self.invert_y = invert_y
+        self.key_width = Decimal('19.05')
+        self.key_skel = {'decal': False, 'border_color': 'none', 'keycap_profile': '', 'keycap_color': 'grey', 'label_color': 'black', 'label_size': 3, 'label_style': 4, 'width': Decimal('1'), 'height': Decimal('1')}
+        self.rows = Decimal(0)
+        self.columns = Decimal(0)
+
+        if layout:
+            self.parse_layout(layout)
+
+    @property
+    def width(self):
+        """Returns the width of the keyboard plate.
+        """
+        return (Decimal(self.columns) * self.key_width) + self.key_width / 2
+
+    @property
+    def height(self):
+        """Returns the height of the keyboard plate.
+        """
+        return (self.rows * self.key_width) + self.key_width / 2
+
+    @property
+    def size(self):
+        """Returns the size of the keyboard plate.
+        """
+        return (self.width, self.height)
+
+    def attrs(self, properties):
+        """Parse the keyboard properties dictionary.
+        """
+        # FIXME: Store more than just the keyboard name.
+        if 'name' in properties:
+            self.name = properties['name']
+
+    def parse_layout(self, layout):  # noqa  FIXME(skullydazed): flake8 says this has a complexity of 25, it should be refactored.
+        # Wrap this in a dictionary so hjson will parse KLE raw data
+        layout = '{"layout": [' + layout + ']}'
+        layout = hjson.loads(layout)['layout']
+
+        # Initialize our state machine
+        current_key = self.key_skel.copy()
+        current_row = Decimal(0)
+        current_col = Decimal(0)
+
+        if isinstance(layout[0], dict):
+            self.attrs(layout[0])
+            layout = layout[1:]
+
+        for row_num, row in enumerate(layout):
+            self.append([])
+
+            # Process the current row
+            for key in row:
+                if isinstance(key, dict):
+                    if 'w' in key and key['w'] != Decimal(1):
+                        current_key['width'] = Decimal(key['w'])
+                    if 'w2' in key and 'h2' in key and key['w2'] == 1.5 and key['h2'] == 1:
+                        # FIXME: ISO Key uses these params: {x:0.25,w:1.25,h:2,w2:1.5,h2:1,x2:-0.25}
+                        current_key['isoenter'] = True
+                    if 'h' in key and key['h'] != Decimal(1):
+                        current_key['height'] = Decimal(key['h'])
+                    if 'a' in key:
+                        current_key['label_style'] = self.key_skel['label_style'] = max(min(int(key['a']), 9), 0)
+                    if 'f' in key:
+                        current_key['label_size'] = self.key_skel['label_size'] = max(min(int(key['f']), 9), 1)
+                    if 'p' in key:
+                        current_key['keycap_profile'] = self.key_skel['keycap_profile'] = key['p']
+                    if 'c' in key:
+                        current_key['keycap_color'] = self.key_skel['keycap_color'] = key['c']
+                    if 't' in key:
+                        # FIXME: Need to do better validation, plus figure out how to support multiple colors
+                        if '\n' in key['t']:
+                            key['t'] = key['t'].split('\n')[0]
+                        if key['t'] == "0":
+                            key['t'] = "#000000"
+                        current_key['label_color'] = self.key_skel['label_color'] = key['t']
+                    if 'x' in key:
+                        current_col += Decimal(key['x'])
+                    if 'y' in key:
+                        current_row += Decimal(key['y'])
+                    if 'd' in key:
+                        current_key['decal'] = True
+
+                else:
+                    current_key['name'] = key
+                    current_key['row'] = round(current_row, 2)
+                    current_key['column'] = round(current_col, 2)
+
+                    # x,y (units mm) is the center of the key
+                    x_center = current_col + current_key['width'] / 2
+                    y_center = current_row + current_key['height'] / 2
+                    current_key['x'] = x_center * self.key_width
+                    current_key['y'] = y_center * self.key_width
+
+                    # Tend to our row/col count
+                    current_col += current_key['width']
+                    if current_col > self.columns:
+                        self.columns = current_col
+
+                    # Invert the y-axis if neccesary
+                    if self.invert_y:
+                        current_key['y'] = -current_key['y']
+
+                    # Store this key
+                    self[-1].append(current_key)
+                    current_key = self.key_skel.copy()
+
+            # Move to the next row
+            current_col = Decimal(0)
+            current_row += Decimal(1)
+            if current_row > self.rows:
+                self.rows = Decimal(current_row)
diff --git a/lib/python/qmk/__init__.py b/lib/python/qmk/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/__init__.py
diff --git a/lib/python/qmk/build_targets.py b/lib/python/qmk/build_targets.py
new file mode 100644
index 0000000000..35a5f89f91
--- /dev/null
+++ b/lib/python/qmk/build_targets.py
@@ -0,0 +1,279 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+import json
+import shutil
+from typing import Dict, List, Union
+from pathlib import Path
+from dotty_dict import dotty, Dotty
+from milc import cli
+from qmk.constants import QMK_FIRMWARE, INTERMEDIATE_OUTPUT_PREFIX, HAS_QMK_USERSPACE, QMK_USERSPACE
+from qmk.commands import find_make, get_make_parallel_args, parse_configurator_json
+from qmk.keyboard import keyboard_folder
+from qmk.info import keymap_json
+from qmk.keymap import locate_keymap
+from qmk.path import is_under_qmk_firmware, is_under_qmk_userspace, unix_style_path
+from qmk.compilation_database import write_compilation_database
+
+# These must be kept in the order in which they're applied to $(TARGET) in the makefiles in order to ensure consistency.
+TARGET_FILENAME_MODIFIERS = ['FORCE_LAYOUT', 'CONVERT_TO']
+
+
+class BuildTarget:
+    def __init__(self, keyboard: str, keymap: str, json: Union[dict, Dotty] = None):
+        self._keyboard = keyboard_folder(keyboard)
+        self._keyboard_safe = self._keyboard.replace('/', '_')
+        self._keymap = keymap
+        self._parallel = 1
+        self._clean = False
+        self._compiledb = False
+        self._extra_args = {}
+        self._json = json.to_dict() if isinstance(json, Dotty) else json
+
+    def __str__(self):
+        return f'{self.keyboard}:{self.keymap}'
+
+    def __repr__(self):
+        if len(self._extra_args.items()) > 0:
+            return f'BuildTarget(keyboard={self.keyboard}, keymap={self.keymap}, extra_args={json.dumps(self._extra_args, sort_keys=True)})'
+        return f'BuildTarget(keyboard={self.keyboard}, keymap={self.keymap})'
+
+    def __lt__(self, __value: object) -> bool:
+        return self.__repr__() < __value.__repr__()
+
+    def __eq__(self, __value: object) -> bool:
+        if not isinstance(__value, BuildTarget):
+            return False
+        return self.__repr__() == __value.__repr__()
+
+    def __hash__(self) -> int:
+        return self.__repr__().__hash__()
+
+    def configure(self, parallel: int = None, clean: bool = None, compiledb: bool = None) -> None:
+        if parallel is not None:
+            self._parallel = parallel
+        if clean is not None:
+            self._clean = clean
+        if compiledb is not None:
+            self._compiledb = compiledb
+
+    @property
+    def keyboard(self) -> str:
+        return self._keyboard
+
+    @property
+    def keymap(self) -> str:
+        return self._keymap
+
+    @property
+    def json(self) -> dict:
+        if not self._json:
+            self._load_json()
+        if not self._json:
+            return {}
+        return self._json
+
+    @property
+    def dotty(self) -> Dotty:
+        return dotty(self.json)
+
+    @property
+    def extra_args(self) -> Dict[str, str]:
+        return {k: v for k, v in self._extra_args.items()}
+
+    @extra_args.setter
+    def extra_args(self, ex_args: Dict[str, str]):
+        if ex_args is not None and isinstance(ex_args, dict):
+            self._extra_args = {k: v for k, v in ex_args.items()}
+
+    def target_name(self, **env_vars) -> str:
+        # Work out the intended target name
+        target = f'{self._keyboard_safe}_{self.keymap}'
+        vars = self._all_vars(**env_vars)
+        for modifier in TARGET_FILENAME_MODIFIERS:
+            if modifier in vars:
+                target += f"_{vars[modifier]}"
+        return target
+
+    def _all_vars(self, **env_vars) -> Dict[str, str]:
+        vars = {k: v for k, v in env_vars.items()}
+        for k, v in self._extra_args.items():
+            vars[k] = v
+        return vars
+
+    def _intermediate_output(self, **env_vars) -> Path:
+        return Path(f'{INTERMEDIATE_OUTPUT_PREFIX}{self.target_name(**env_vars)}')
+
+    def _common_make_args(self, dry_run: bool = False, build_target: str = None, **env_vars):
+        compile_args = [
+            find_make(),
+            *get_make_parallel_args(self._parallel),
+            '-r',
+            '-R',
+            '-f',
+            'builddefs/build_keyboard.mk',
+        ]
+
+        if not cli.config.general.verbose:
+            compile_args.append('-s')
+
+        verbose = 'true' if cli.config.general.verbose else 'false'
+        color = 'true' if cli.config.general.color else 'false'
+
+        if dry_run:
+            compile_args.append('-n')
+
+        if build_target:
+            compile_args.append(build_target)
+
+        compile_args.extend([
+            f'KEYBOARD={self.keyboard}',
+            f'KEYMAP={self.keymap}',
+            f'KEYBOARD_FILESAFE={self._keyboard_safe}',
+            f'TARGET={self._keyboard_safe}_{self.keymap}',  # don't use self.target_name() here, it's rebuilt on the makefile side
+            f'VERBOSE={verbose}',
+            f'COLOR={color}',
+            'SILENT=false',
+            'QMK_BIN="qmk"',
+        ])
+
+        vars = self._all_vars(**env_vars)
+        for k, v in vars.items():
+            compile_args.append(f'{k}={v}')
+
+        return compile_args
+
+    def prepare_build(self, build_target: str = None, dry_run: bool = False, **env_vars) -> None:
+        raise NotImplementedError("prepare_build() not implemented in base class")
+
+    def compile_command(self, build_target: str = None, dry_run: bool = False, **env_vars) -> List[str]:
+        raise NotImplementedError("compile_command() not implemented in base class")
+
+    def generate_compilation_database(self, build_target: str = None, skip_clean: bool = False, **env_vars) -> None:
+        self.prepare_build(build_target=build_target, **env_vars)
+        command = self.compile_command(build_target=build_target, dry_run=True, **env_vars)
+        output_path = QMK_FIRMWARE / 'compile_commands.json'
+        ret = write_compilation_database(command=command, output_path=output_path, skip_clean=skip_clean, **env_vars)
+        if ret and output_path.exists() and HAS_QMK_USERSPACE:
+            shutil.copy(str(output_path), str(QMK_USERSPACE / 'compile_commands.json'))
+        return ret
+
+    def compile(self, build_target: str = None, dry_run: bool = False, **env_vars) -> None:
+        if self._clean or self._compiledb:
+            command = [find_make(), "clean"]
+            if dry_run:
+                command.append('-n')
+            cli.log.info('Cleaning with {fg_cyan}%s', ' '.join(command))
+            cli.run(command, capture_output=False)
+
+        if self._compiledb and not dry_run:
+            self.generate_compilation_database(build_target=build_target, skip_clean=True, **env_vars)
+
+        self.prepare_build(build_target=build_target, dry_run=dry_run, **env_vars)
+        command = self.compile_command(build_target=build_target, **env_vars)
+        cli.log.info('Compiling keymap with {fg_cyan}%s', ' '.join(command))
+        if not dry_run:
+            cli.echo('\n')
+            ret = cli.run(command, capture_output=False)
+            if ret.returncode:
+                return ret.returncode
+
+
+class KeyboardKeymapBuildTarget(BuildTarget):
+    def __init__(self, keyboard: str, keymap: str, json: dict = None):
+        super().__init__(keyboard=keyboard, keymap=keymap, json=json)
+
+    def __repr__(self):
+        if len(self._extra_args.items()) > 0:
+            return f'KeyboardKeymapTarget(keyboard={self.keyboard}, keymap={self.keymap}, extra_args={self._extra_args})'
+        return f'KeyboardKeymapTarget(keyboard={self.keyboard}, keymap={self.keymap})'
+
+    def _load_json(self):
+        self._json = keymap_json(self.keyboard, self.keymap)
+
+    def prepare_build(self, build_target: str = None, dry_run: bool = False, **env_vars) -> None:
+        pass
+
+    def compile_command(self, build_target: str = None, dry_run: bool = False, **env_vars) -> List[str]:
+        compile_args = self._common_make_args(dry_run=dry_run, build_target=build_target, **env_vars)
+
+        # Need to override the keymap path if the keymap is a userspace directory.
+        # This also ensures keyboard aliases as per `keyboard_aliases.hjson` still work if the userspace has the keymap
+        # in an equivalent historical location.
+        vars = self._all_vars(**env_vars)
+        keymap_location = locate_keymap(self.keyboard, self.keymap, force_layout=vars.get('FORCE_LAYOUT'))
+        if is_under_qmk_userspace(keymap_location) and not is_under_qmk_firmware(keymap_location):
+            keymap_directory = keymap_location.parent
+            compile_args.extend([
+                f'MAIN_KEYMAP_PATH_1={unix_style_path(keymap_directory)}',
+                f'MAIN_KEYMAP_PATH_2={unix_style_path(keymap_directory)}',
+                f'MAIN_KEYMAP_PATH_3={unix_style_path(keymap_directory)}',
+                f'MAIN_KEYMAP_PATH_4={unix_style_path(keymap_directory)}',
+                f'MAIN_KEYMAP_PATH_5={unix_style_path(keymap_directory)}',
+            ])
+
+        return compile_args
+
+
+class JsonKeymapBuildTarget(BuildTarget):
+    def __init__(self, json_path):
+        if isinstance(json_path, Path):
+            self.json_path = json_path
+        else:
+            self.json_path = None
+
+        json = parse_configurator_json(json_path)  # Will load from stdin if provided
+
+        # In case the user passes a keymap.json from a keymap directory directly to the CLI.
+        # e.g.: qmk compile - < keyboards/clueboard/california/keymaps/default/keymap.json
+        json["keymap"] = json.get("keymap", "default_json")
+
+        super().__init__(keyboard=json['keyboard'], keymap=json['keymap'], json=json)
+
+    def __repr__(self):
+        if len(self._extra_args.items()) > 0:
+            return f'JsonKeymapTarget(keyboard={self.keyboard}, keymap={self.keymap}, path={self.json_path}, extra_args={self._extra_args})'
+        return f'JsonKeymapTarget(keyboard={self.keyboard}, keymap={self.keymap}, path={self.json_path})'
+
+    def _load_json(self):
+        pass  # Already loaded in constructor
+
+    def prepare_build(self, build_target: str = None, dry_run: bool = False, **env_vars) -> None:
+        intermediate_output = self._intermediate_output(**env_vars)
+        generated_files_path = intermediate_output / 'src'
+        keymap_json = generated_files_path / 'keymap.json'
+
+        if self._clean:
+            if intermediate_output.exists():
+                shutil.rmtree(intermediate_output)
+
+        # begin with making the deepest folder in the tree
+        generated_files_path.mkdir(exist_ok=True, parents=True)
+
+        # Compare minified to ensure consistent comparison
+        new_content = json.dumps(self.json, separators=(',', ':'))
+        if keymap_json.exists():
+            old_content = json.dumps(json.loads(keymap_json.read_text(encoding='utf-8')), separators=(',', ':'))
+            if old_content == new_content:
+                new_content = None
+
+        # Write the keymap.json file if different so timestamps are only updated
+        # if the content changes -- running `make` won't treat it as modified.
+        if new_content:
+            keymap_json.write_text(new_content, encoding='utf-8')
+
+    def compile_command(self, build_target: str = None, dry_run: bool = False, **env_vars) -> List[str]:
+        compile_args = self._common_make_args(dry_run=dry_run, build_target=build_target, **env_vars)
+        intermediate_output = self._intermediate_output(**env_vars)
+        generated_files_path = intermediate_output / 'src'
+        keymap_json = generated_files_path / 'keymap.json'
+        compile_args.extend([
+            f'MAIN_KEYMAP_PATH_1={unix_style_path(intermediate_output)}',
+            f'MAIN_KEYMAP_PATH_2={unix_style_path(intermediate_output)}',
+            f'MAIN_KEYMAP_PATH_3={unix_style_path(intermediate_output)}',
+            f'MAIN_KEYMAP_PATH_4={unix_style_path(intermediate_output)}',
+            f'MAIN_KEYMAP_PATH_5={unix_style_path(intermediate_output)}',
+            f'KEYMAP_JSON={keymap_json}',
+            f'KEYMAP_PATH={generated_files_path}',
+        ])
+
+        return compile_args
diff --git a/lib/python/qmk/c_parse.py b/lib/python/qmk/c_parse.py
new file mode 100644
index 0000000000..785b940456
--- /dev/null
+++ b/lib/python/qmk/c_parse.py
@@ -0,0 +1,324 @@
+"""Functions for working with config.h files.
+"""
+from pygments.lexers.c_cpp import CLexer
+from pygments.token import Token
+from pygments import lex
+from itertools import islice
+from pathlib import Path
+import re
+
+from milc import cli
+
+from qmk.comment_remover import comment_remover
+
+default_key_entry = {'x': -1, 'y': 0}
+single_comment_regex = re.compile(r'\s+/[/*].*$')
+multi_comment_regex = re.compile(r'/\*(.|\n)*?\*/', re.MULTILINE)
+layout_macro_define_regex = re.compile(r'^#\s*define')
+
+
+def _get_chunks(it, size):
+    """Break down a collection into smaller parts
+    """
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+def preprocess_c_file(file):
+    """Load file and strip comments
+    """
+    file_contents = file.read_text(encoding='utf-8')
+    file_contents = comment_remover(file_contents)
+    return file_contents.replace('\\\n', '')
+
+
+def strip_line_comment(string):
+    """Removes comments from a single line string.
+    """
+    return single_comment_regex.sub('', string)
+
+
+def strip_multiline_comment(string):
+    """Removes comments from a single line string.
+    """
+    return multi_comment_regex.sub('', string)
+
+
+def c_source_files(dir_names):
+    """Returns a list of all *.c, *.h, and *.cpp files for a given list of directories
+
+    Args:
+
+        dir_names
+            List of directories relative to `qmk_firmware`.
+    """
+    files = []
+    for dir in dir_names:
+        files.extend(file for file in Path(dir).glob('**/*') if file.suffix in ['.c', '.h', '.cpp'])
+    return files
+
+
+def find_layouts(file):
+    """Returns list of parsed LAYOUT preprocessor macros found in the supplied include file.
+    """
+    file = Path(file)
+    aliases = {}  # Populated with all `#define`s that aren't functions
+    parsed_layouts = {}
+
+    # Search the file for LAYOUT macros and aliases
+    file_contents = preprocess_c_file(file)
+
+    for line in file_contents.split('\n'):
+        if layout_macro_define_regex.match(line.lstrip()) and '(' in line and 'LAYOUT' in line:
+            # We've found a LAYOUT macro
+            macro_name, layout, matrix = _parse_layout_macro(line.strip())
+
+            # Reject bad macro names
+            if macro_name.startswith('LAYOUT_kc') or not macro_name.startswith('LAYOUT'):
+                continue
+
+            # Parse the matrix data
+            matrix_locations = _parse_matrix_locations(matrix, file, macro_name)
+
+            # Parse the layout entries into a basic structure
+            default_key_entry['x'] = -1  # Set to -1 so _default_key(key) will increment it to 0
+            layout = layout.strip()
+            parsed_layout = [_default_key(key) for key in layout.split(',')]
+
+            for i, key in enumerate(parsed_layout):
+                if 'label' not in key:
+                    cli.log.error('Invalid LAYOUT macro in %s: Empty parameter name in macro %s at pos %s.', file, macro_name, i)
+                elif key['label'] not in matrix_locations:
+                    cli.log.error('Invalid LAYOUT macro in %s: Key %s in macro %s has no matrix position!', file, key['label'], macro_name)
+                elif len(matrix_locations.get(key['label'])) > 1:
+                    cli.log.error('Invalid LAYOUT macro in %s: Key %s in macro %s has multiple matrix positions (%s)', file, key['label'], macro_name, ', '.join(str(x) for x in matrix_locations[key['label']]))
+                else:
+                    key['matrix'] = matrix_locations[key['label']][0]
+
+            parsed_layouts[macro_name] = {
+                'layout': parsed_layout,
+                'filename': str(file),
+            }
+
+        elif '#define' in line:
+            # Attempt to extract a new layout alias
+            try:
+                _, pp_macro_name, pp_macro_text = line.strip().split(' ', 2)
+                aliases[pp_macro_name] = pp_macro_text
+            except ValueError:
+                continue
+
+    return parsed_layouts, aliases
+
+
+def parse_config_h_file(config_h_file, config_h=None):
+    """Extract defines from a config.h file.
+    """
+    if not config_h:
+        config_h = {}
+
+    config_h_file = Path(config_h_file)
+
+    if config_h_file.exists():
+        config_h_text = config_h_file.read_text(encoding='utf-8')
+        config_h_text = config_h_text.replace('\\\n', '')
+        config_h_text = strip_multiline_comment(config_h_text)
+
+        for linenum, line in enumerate(config_h_text.split('\n')):
+            line = strip_line_comment(line).strip()
+
+            if not line:
+                continue
+
+            line = line.split()
+
+            if line[0] == '#define':
+                if len(line) == 1:
+                    cli.log.error('%s: Incomplete #define! On or around line %s' % (config_h_file, linenum))
+                elif len(line) == 2:
+                    config_h[line[1]] = True
+                else:
+                    config_h[line[1]] = ' '.join(line[2:])
+
+            elif line[0] == '#undef':
+                if len(line) == 2:
+                    if line[1] in config_h:
+                        if config_h[line[1]] is True:
+                            del config_h[line[1]]
+                        else:
+                            config_h[line[1]] = False
+                else:
+                    cli.log.error('%s: Incomplete #undef! On or around line %s' % (config_h_file, linenum))
+
+    return config_h
+
+
+def _default_key(label=None):
+    """Increment x and return a copy of the default_key_entry.
+    """
+    default_key_entry['x'] += 1
+    new_key = default_key_entry.copy()
+
+    if label:
+        new_key['label'] = label
+
+    return new_key
+
+
+def _parse_layout_macro(layout_macro):
+    """Split the LAYOUT macro into its constituent parts
+    """
+    layout_macro = layout_macro.replace('\\', '').replace(' ', '').replace('\t', '').replace('#define', '')
+    macro_name, layout = layout_macro.split('(', 1)
+    layout, matrix = layout.split(')', 1)
+
+    return macro_name, layout, matrix
+
+
+def _parse_matrix_locations(matrix, file, macro_name):
+    """Parse raw matrix data into a dictionary keyed by the LAYOUT identifier.
+    """
+    matrix_locations = {}
+
+    for row_num, row in enumerate(matrix.split('},{')):
+        if row.startswith('LAYOUT'):
+            cli.log.error('%s: %s: Nested layout macro detected. Matrix data not available!', file, macro_name)
+            break
+
+        row = row.replace('{', '').replace('}', '')
+        for col_num, identifier in enumerate(row.split(',')):
+            if identifier != 'KC_NO':
+                if identifier not in matrix_locations:
+                    matrix_locations[identifier] = []
+                matrix_locations[identifier].append([row_num, col_num])
+
+    return matrix_locations
+
+
+def _coerce_led_token(_type, value):
+    """ Convert token to valid info.json content
+    """
+    value_map = {
+        'NO_LED': None,
+        'LED_FLAG_ALL': 0xFF,
+        'LED_FLAG_NONE': 0x00,
+        'LED_FLAG_MODIFIER': 0x01,
+        'LED_FLAG_UNDERGLOW': 0x02,
+        'LED_FLAG_KEYLIGHT': 0x04,
+        'LED_FLAG_INDICATOR': 0x08,
+    }
+    if _type is Token.Literal.Number.Integer:
+        return int(value)
+    if _type is Token.Literal.Number.Float:
+        return float(value)
+    if _type is Token.Literal.Number.Hex:
+        return int(value, 0)
+    if _type is Token.Name and value in value_map.keys():
+        return value_map[value]
+
+
+def _validate_led_config(matrix, matrix_rows, matrix_cols, matrix_indexes, position, position_raw, flags):
+    # TODO: Improve crude parsing/validation
+    if len(matrix) != matrix_rows and len(matrix) != (matrix_rows / 2):
+        raise ValueError("Unable to parse g_led_config matrix data")
+    for index, row in enumerate(matrix):
+        if len(row) != matrix_cols:
+            raise ValueError(f"Number of columns in row {index} ({len(row)}) does not match matrix ({matrix_cols})")
+    if len(position) != len(flags):
+        raise ValueError(f"Number of g_led_config physical positions ({len(position)}) does not match number of flags ({len(flags)})")
+    if len(matrix_indexes) and (max(matrix_indexes) >= len(flags)):
+        raise ValueError(f"LED index {max(matrix_indexes)} is OOB in g_led_config - should be < {len(flags)}")
+    if not all(isinstance(n, int) for n in matrix_indexes):
+        raise ValueError("matrix indexes are not all ints")
+    if (len(position_raw) % 2) != 0:
+        raise ValueError("Malformed g_led_config position data")
+
+
+def _parse_led_config(file, matrix_cols, matrix_rows):
+    """Return any 'raw' led/rgb matrix config
+    """
+    matrix = []
+    position_raw = []
+    flags = []
+
+    found_led_config_t = False
+    found_g_led_config = False
+    bracket_count = 0
+    section = 0
+    current_row_index = 0
+    current_row = []
+
+    for _type, value in lex(preprocess_c_file(file), CLexer()):
+        if not found_g_led_config:
+            # Check for type
+            if value == 'led_config_t':
+                found_led_config_t = True
+            # Type found, now check for name
+            elif found_led_config_t and value == 'g_led_config':
+                found_g_led_config = True
+        elif value == ';':
+            found_g_led_config = False
+        else:
+            # Assume bracket count hints to section of config we are within
+            if value == '{':
+                bracket_count += 1
+                if bracket_count == 2:
+                    section += 1
+            elif value == '}':
+                if section == 1 and bracket_count == 3:
+                    matrix.append(current_row)
+                    current_row = []
+                    current_row_index += 1
+                bracket_count -= 1
+            else:
+                # Assume any non whitespace value here is important enough to stash
+                if _type in [Token.Literal.Number.Integer, Token.Literal.Number.Float, Token.Literal.Number.Hex, Token.Name]:
+                    if section == 1 and bracket_count == 3:
+                        current_row.append(_coerce_led_token(_type, value))
+                    if section == 2 and bracket_count == 3:
+                        position_raw.append(_coerce_led_token(_type, value))
+                    if section == 3 and bracket_count == 2:
+                        flags.append(_coerce_led_token(_type, value))
+                elif _type in [Token.Comment.Preproc]:
+                    # TODO: Promote to error
+                    return None
+
+    # Slightly better intrim format
+    position = list(_get_chunks(position_raw, 2))
+    matrix_indexes = list(filter(lambda x: x is not None, sum(matrix, [])))
+
+    # If we have not found anything - bail with no error
+    if not section:
+        return None
+
+    # Throw any validation errors
+    _validate_led_config(matrix, matrix_rows, matrix_cols, matrix_indexes, position, position_raw, flags)
+
+    return (matrix, position, flags)
+
+
+def find_led_config(file, matrix_cols, matrix_rows):
+    """Search file for led/rgb matrix config
+    """
+    found = _parse_led_config(file, matrix_cols, matrix_rows)
+    if not found:
+        return None
+
+    # Expand collected content
+    (matrix, position, flags) = found
+
+    # Align to output format
+    led_config = []
+    for index, item in enumerate(position, start=0):
+        led_config.append({
+            'x': item[0],
+            'y': item[1],
+            'flags': flags[index],
+        })
+    for r in range(len(matrix)):
+        for c in range(len(matrix[r])):
+            index = matrix[r][c]
+            if index is not None:
+                led_config[index]['matrix'] = [r, c]
+
+    return led_config
diff --git a/lib/python/qmk/cli/__init__.py b/lib/python/qmk/cli/__init__.py
new file mode 100644
index 0000000000..dc2e4726a5
--- /dev/null
+++ b/lib/python/qmk/cli/__init__.py
@@ -0,0 +1,288 @@
+"""QMK CLI Subcommands
+
+We list each subcommand here explicitly because all the reliable ways of searching for modules are slow and delay startup.
+"""
+import os
+import platform
+import platformdirs
+import shlex
+import sys
+from importlib.util import find_spec
+from pathlib import Path
+from subprocess import run
+
+from milc import cli, __VERSION__
+from milc.questions import yesno
+
+
+def _get_default_distrib_path():
+    if 'windows' in platform.platform().lower():
+        try:
+            result = cli.run(['cygpath', '-w', '/opt/qmk'])
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except Exception:
+            pass
+
+    return platformdirs.user_data_dir('qmk')
+
+
+# Ensure the QMK distribution is on the `$PATH` if present. This must be kept in sync with qmk/qmk_cli.
+QMK_DISTRIB_DIR = Path(os.environ.get('QMK_DISTRIB_DIR', _get_default_distrib_path()))
+if QMK_DISTRIB_DIR.exists():
+    os.environ['PATH'] = str(QMK_DISTRIB_DIR / 'bin') + os.pathsep + os.environ['PATH']
+
+# Prepend any user-defined path prefix
+if 'QMK_PATH_PREFIX' in os.environ:
+    os.environ['PATH'] = os.environ['QMK_PATH_PREFIX'] + os.pathsep + os.environ['PATH']
+
+import_names = {
+    # A mapping of package name to importable name
+    'pep8-naming': 'pep8ext_naming',
+    'pyserial': 'serial',
+    'pyusb': 'usb.core',
+    'qmk-dotty-dict': 'dotty_dict',
+    'pillow': 'PIL'
+}
+
+safe_commands = [
+    # A list of subcommands we always run, even when the module imports fail
+    'clone',
+    'config',
+    'doctor',
+    'env',
+    'setup',
+]
+
+subcommands = [
+    'qmk.cli.ci.validate_aliases',
+    'qmk.cli.bux',
+    'qmk.cli.c2json',
+    'qmk.cli.cd',
+    'qmk.cli.chibios.confmigrate',
+    'qmk.cli.clean',
+    'qmk.cli.compile',
+    'qmk.cli.docs',
+    'qmk.cli.doctor',
+    'qmk.cli.find',
+    'qmk.cli.flash',
+    'qmk.cli.format.c',
+    'qmk.cli.format.json',
+    'qmk.cli.format.python',
+    'qmk.cli.format.text',
+    'qmk.cli.generate.api',
+    'qmk.cli.generate.autocorrect_data',
+    'qmk.cli.generate.compilation_database',
+    'qmk.cli.generate.community_modules',
+    'qmk.cli.generate.config_h',
+    'qmk.cli.generate.develop_pr_list',
+    'qmk.cli.generate.dfu_header',
+    'qmk.cli.generate.docs',
+    'qmk.cli.generate.info_json',
+    'qmk.cli.generate.keyboard_c',
+    'qmk.cli.generate.keyboard_h',
+    'qmk.cli.generate.keycodes',
+    'qmk.cli.generate.keymap_h',
+    'qmk.cli.generate.make_dependencies',
+    'qmk.cli.generate.rgb_breathe_table',
+    'qmk.cli.generate.rules_mk',
+    'qmk.cli.generate.version_h',
+    'qmk.cli.git.submodule',
+    'qmk.cli.hello',
+    'qmk.cli.import.kbfirmware',
+    'qmk.cli.import.keyboard',
+    'qmk.cli.import.keymap',
+    'qmk.cli.info',
+    'qmk.cli.json2c',
+    'qmk.cli.license_check',
+    'qmk.cli.lint',
+    'qmk.cli.kle2json',
+    'qmk.cli.list.keyboards',
+    'qmk.cli.list.keymaps',
+    'qmk.cli.list.layouts',
+    'qmk.cli.mass_compile',
+    'qmk.cli.migrate',
+    'qmk.cli.new.keyboard',
+    'qmk.cli.new.keymap',
+    'qmk.cli.painter',
+    'qmk.cli.pytest',
+    'qmk.cli.resolve_alias',
+    'qmk.cli.test.c',
+    'qmk.cli.userspace.add',
+    'qmk.cli.userspace.compile',
+    'qmk.cli.userspace.doctor',
+    'qmk.cli.userspace.list',
+    'qmk.cli.userspace.path',
+    'qmk.cli.userspace.remove',
+    'qmk.cli.via2json',
+]
+
+
+def _install_deps(requirements):
+    """Perform the installation of missing requirements.
+
+    If we detect that we are running in a virtualenv we can't write into we'll use sudo to perform the pip install.
+    """
+    command = [sys.executable, '-m', 'pip', 'install']
+
+    if sys.prefix != sys.base_prefix:
+        # We are in a virtualenv, check to see if we need to use sudo to write to it
+        if not os.access(sys.prefix, os.W_OK):
+            print('Notice: Using sudo to install modules to location owned by root:', sys.prefix)
+            command.insert(0, 'sudo')
+
+    elif not os.access(sys.prefix, os.W_OK):
+        # We can't write to sys.prefix, attempt to install locally
+        command.append('--user')
+
+    return _run_cmd(*command, '-r', requirements)
+
+
+def _run_cmd(*command):
+    """Run a command in a subshell.
+    """
+    if 'windows' in cli.platform.lower():
+        safecmd = map(shlex.quote, command)
+        safecmd = ' '.join(safecmd)
+        command = [os.environ['SHELL'], '-c', safecmd]
+
+    return run(command)
+
+
+def _find_broken_requirements(requirements):
+    """ Check if the modules in the given requirements.txt are available.
+
+    Args:
+
+        requirements
+            The path to a requirements.txt file
+
+    Returns a list of modules that couldn't be imported
+    """
+    with Path(requirements).open() as fd:
+        broken_modules = []
+
+        for line in fd.readlines():
+            line = line.strip().replace('<', '=').replace('>', '=')
+
+            if len(line) == 0 or line[0] == '#' or line.startswith('-r'):
+                continue
+
+            if '#' in line:
+                line = line.split('#')[0]
+
+            module_name = line.split('=')[0] if '=' in line else line
+            module_import = module_name.replace('-', '_')
+
+            # Not every module is importable by its own name.
+            if module_name in import_names:
+                module_import = import_names[module_name]
+
+            if not find_spec(module_import):
+                broken_modules.append(module_name)
+
+        return broken_modules
+
+
+def _broken_module_imports(requirements):
+    """Make sure we can import all the python modules.
+    """
+    broken_modules = _find_broken_requirements(requirements)
+
+    for module in broken_modules:
+        print('Could not find module %s!' % module)
+
+    if broken_modules:
+        return True
+
+    return False
+
+
+def _yesno(*args):
+    """Wrapper to only prompt if interactive
+    """
+    return sys.stdout.isatty() and yesno(*args)
+
+
+def _eprint(errmsg):
+    """Wrapper to print to stderr
+    """
+    print(errmsg, file=sys.stderr)
+
+
+# Make sure our python is new enough
+#
+# Supported version information
+#
+# Based on the OSes we support these are the minimum python version available by default.
+# Last update: 2024 Jun 24
+#
+# Arch: 3.12
+# Debian 11: 3.9
+# Debian 12: 3.11
+# Fedora 39: 3.12
+# Fedora 40: 3.12
+# FreeBSD: 3.11
+# Gentoo: 3.12
+# macOS: 3.12 (from homebrew)
+# msys2: 3.11
+# Slackware: 3.9
+# solus: 3.10
+# Ubuntu 22.04: 3.10
+# Ubuntu 24.04: 3.12
+# void: 3.12
+
+if sys.version_info[0] != 3 or sys.version_info[1] < 9:
+    _eprint('Error: Your Python is too old! Please upgrade to Python 3.9 or later.')
+    exit(127)
+
+milc_version = __VERSION__.split('.')
+
+if int(milc_version[0]) < 2 and int(milc_version[1]) < 9:
+    requirements = Path('requirements.txt').resolve()
+
+    _eprint(f'Your MILC library is too old! Please upgrade: python3 -m pip install -U -r {str(requirements)}')
+    exit(127)
+
+# Make sure we can run binaries in the same directory as our Python interpreter
+python_dir = os.path.dirname(sys.executable)
+
+if python_dir not in os.environ['PATH'].split(os.pathsep):
+    os.environ['PATH'] = os.pathsep.join((python_dir, os.environ['PATH']))
+
+# Check to make sure we have all our dependencies
+msg_install = f'\nPlease run `{sys.executable} -m pip install -r %s` to install required python dependencies.'
+args = sys.argv[1:]
+while args and args[0][0] == '-':
+    del args[0]
+
+safe_command = args and args[0] in safe_commands
+
+if not safe_command:
+    if _broken_module_imports('requirements.txt'):
+        if _yesno('Would you like to install the required Python modules?'):
+            _install_deps('requirements.txt')
+        else:
+            _eprint(msg_install % (str(Path('requirements.txt').resolve()),))
+            exit(1)
+
+    if cli.config.user.developer and _broken_module_imports('requirements-dev.txt'):
+        if _yesno('Would you like to install the required developer Python modules?'):
+            _install_deps('requirements-dev.txt')
+        elif _yesno('Would you like to disable developer mode?'):
+            _run_cmd(sys.argv[0], 'config', 'user.developer=None')
+        else:
+            _eprint(msg_install % (str(Path('requirements-dev.txt').resolve()),))
+            _eprint('You can also turn off developer mode: qmk config user.developer=None')
+            exit(1)
+
+# Import our subcommands
+for subcommand in subcommands:
+    try:
+        __import__(subcommand)
+
+    except (ImportError, ModuleNotFoundError) as e:
+        if safe_command:
+            _eprint(f'Warning: Could not import {subcommand}: {e.__class__.__name__}, {e}')
+        else:
+            raise
diff --git a/lib/python/qmk/cli/bux.py b/lib/python/qmk/cli/bux.py
new file mode 100755
index 0000000000..669521d08e
--- /dev/null
+++ b/lib/python/qmk/cli/bux.py
@@ -0,0 +1,49 @@
+"""QMK Bux
+
+World domination secret weapon.
+"""
+from milc import cli
+from milc.subcommand import config
+
+
+@cli.subcommand('QMK Bux miner.', hidden=True)
+def bux(cli):
+    """QMK bux
+    """
+    if not cli.config.user.bux:
+        bux = 0
+    else:
+        bux = cli.config.user.bux
+
+    cli.args.read_only = False
+    config.set_config('user', 'bux', bux + 1)
+    cli.save_config()
+
+    buck = r"""
+@@BBBBBBBBBBBBBBBBBBBBK    `vP8#####BE2~   x###g_     `S###q  n##}  -j#Bl.   vBBBBBBBBBBBBBBBBBBBB@@
+@B   `:!:                 ^#@#]-   `!t@@&. 7@@B@#^   _Q@Q@@R  y@@l:P@#1'                   `!!_   B@
+@B  r@@@B                 g@@|      ` N@@u 7@@iv@@u *#@z"@@R  y@@&@@Q-                    l@@@D   B@
+@B   !#@B                 ^#@#x-   I@B@@&' 7@@i "B@Q@@r _@@R  y@@l.k#@W:                  `:@@D   B@
+@B    B@B                  `v3g#####B0N#d. v##x  'ckk:  -##A  u##i  `lB#I_                  @@D   B@
+@B    B@B                                                                                   @@D   B@
+@B    B@B                                    `._":!!!=~^*|)r^~:'                            @@D   B@
+@B    ~*~                             `,=)]}y2tjIIfKfKfaPsffsWsUyx~.                        **!   B@
+@B          .*r***r=              _*]yzKsqKUfz22IAA3HzzUjtktzHWsHsIz].                            B@
+@B         )v`  ,  !1-         -rysHHUzUzo2jzoI22ztzkyykt2zjzUzIa3qPsl'        !r*****`           B@
+@B        :}    @`  .j       `xzqdAfzKWsj2kkcycczqAsk2zHbg&ER5q55SNN5U~   !RBB#d`c#1 f#\BQ&v      B@
+@B        _y   ]#   ,c       vUWNWWPsfsssN9WyccnckAfUfWb0DR0&R5RRRddq2_  `@D`jr@2U@#c3@1@Qc-      B@
+@B         !7!    .r]`       }AE0RdRqNd9dNR9fUIzzosPqqAddNNdER9EE9dPy!    BQ!zy@iU@.Q@@y@8x-      B@
+@B           :****>.         '7adddDdR&gRNdRbd&dNNbbRdNdd5NdRRD0RSf}-     .k0&EW`xR .8Q=NRRx      B@
+@B        =**-rx*r}r~}"        ;n2jkzsf3N3zsKsP5dddRddddRddNNqPzy\"            '~****"            B@
+@B        :!!~!;=~r>:*_         `:^vxikylulKfHkyjzzozoIoklix|^!-`                                 B@
+@B                                    ```'-_""::::!:_-.``                                         B@
+@B   `-                                                                                       .`  B@
+@B   r@=                                  In source we trust                                  @H  B@
+@B   r@=                                                                                      @H  B@
+@B  -g@=                `}&###E7  W#g. :#Q n####~   R###8k ;#&  `##.7#8-`R#z                 t@H  B@
+@B   r@=                8@R=-=R@g R@@#:!@@ 2@&!:`   8@1=@@!*@B  `@@- v@#8@y                   @H  B@
+@B   r@=               :@@-   _@@_R@fB#}@@ 2@@@#    8@@#@Q.*@B  `@@-  y@@N                    @H  B@
+@B   `.                 g@9=_~D@g R@}`&@@@ 2@&__`   8@u_Q@2!@@^-x@@` Y@QD@z                   .`  B@
+@@BBBBBBBBBBBBBBBBBBB_  `c8@@@81` S#] `N#B l####v   D###BA. vg@@#0~ i#&' 5#K   RBBBBBBBBBBBBBBBBBB@@
+""" # noqa: Do not care about the ASCII art
+    print(f"{buck}\nYou've been blessed by the QMK gods!\nYou have {cli.config.user.bux} QMK bux.")
diff --git a/lib/python/qmk/cli/c2json.py b/lib/python/qmk/cli/c2json.py
new file mode 100644
index 0000000000..f7f1f2ffba
--- /dev/null
+++ b/lib/python/qmk/cli/c2json.py
@@ -0,0 +1,73 @@
+"""Generate a keymap.json from a keymap.c file.
+"""
+import re
+import json
+
+from argcomplete.completers import FilesCompleter
+from milc import cli
+
+import qmk.path
+from qmk.json_encoders import InfoJSONEncoder
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.keymap import locate_keymap, find_keymap_from_dir, generate_json, c2json as c2json_impl
+from qmk.errors import CppError
+from qmk.commands import dump_lines
+
+
+@cli.argument('--no-cpp', arg_only=True, action='store_false', help='Do not use \'cpp\' on keymap.c')
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='The keyboard\'s name')
+@cli.argument('-km', '--keymap', help='The keymap\'s name')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.c'), help='keymap.c file')
+@cli.subcommand('Creates a keymap.json from a keymap.c file.')
+@automagic_keyboard
+@automagic_keymap
+def c2json(cli):
+    """Generate a keymap.json from a keymap.c file.
+
+    This command uses the `qmk.keymap` module to generate a keymap.json from a keymap.c file. The generated keymap is written to stdout, or to a file if -o is provided.
+    """
+    filename = cli.args.filename
+    keyboard = cli.config.c2json.keyboard
+    keymap = cli.config.c2json.keymap
+
+    if filename:
+        if not keyboard and not keymap:
+            # fallback to inferring keyboard/keymap from path
+            (keymap, found_type) = find_keymap_from_dir(filename)
+            if found_type == 'keymap_directory':
+                keyboard = re.search(fr"keyboards/(.+)/keymaps/{keymap}/.*", filename.as_posix()).group(1)
+
+    elif keyboard and keymap:
+        if not filename:
+            # fallback to inferring keyboard/keymap from path
+            filename = locate_keymap(keyboard, keymap)
+
+    if not all((filename, keyboard, keymap)):
+        cli.log.error('You must supply keyboard and keymap, a path to a keymap.c within qmk_firmware, or absolute filename and keyboard and keymap')
+        cli.print_help()
+        return False
+
+    try:
+        keymap_json = c2json_impl(keyboard, keymap, filename, use_cpp=cli.args.no_cpp)
+    except CppError as e:
+        if cli.config.general.verbose:
+            cli.log.debug('The C pre-processor ran into a fatal error: %s', e)
+        cli.log.error('Something went wrong. Try to use --no-cpp.\nUse the CLI in verbose mode to find out more.')
+        return False
+
+    # Generate the keymap.json
+    try:
+        keymap_json = generate_json(keymap_json['keymap'], keymap_json['keyboard'], keymap_json['layout'], keymap_json['layers'])
+    except KeyError:
+        cli.log.error('Something went wrong. Try to use --no-cpp.')
+        return False
+
+    if cli.args.output:
+        keymap_lines = [json.dumps(keymap_json, cls=InfoJSONEncoder, sort_keys=True)]
+    else:
+        keymap_lines = [json.dumps(keymap_json)]
+
+    dump_lines(cli.args.output, keymap_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/cd.py b/lib/python/qmk/cli/cd.py
new file mode 100755
index 0000000000..ef03011f1f
--- /dev/null
+++ b/lib/python/qmk/cli/cd.py
@@ -0,0 +1,47 @@
+"""Open a shell in the QMK Home directory
+"""
+import sys
+import os
+import subprocess
+
+from milc import cli
+
+from qmk.path import under_qmk_firmware
+
+
+@cli.subcommand('Go to QMK Home')
+def cd(cli):
+    """Go to QMK Home
+    """
+    if not sys.stdout.isatty():
+        cli.log.error("This command is for interactive usage only. For non-interactive usage, 'cd $(qmk env QMK_HOME)' is more robust.")
+        sys.exit(1)
+
+    if not under_qmk_firmware():
+        # Only do anything if the user is not under qmk_firmware already
+        # in order to reduce the possibility of starting multiple shells
+        cli.log.info("Spawning a subshell in your QMK_HOME directory.")
+        cli.log.info("Type 'exit' to get back to the parent shell.")
+        if not cli.platform.lower().startswith('windows'):
+            # For Linux/Mac/etc
+            # Check the user's login shell from 'passwd'
+            # alternatively fall back to $SHELL env var
+            # and finally to '/bin/bash'.
+            import getpass
+            import pwd
+            shell = pwd.getpwnam(getpass.getuser()).pw_shell
+            if not shell:
+                shell = os.environ.get('SHELL', '/bin/bash')
+            # Start the new subshell
+            os.execl(shell, shell)
+        else:
+            # For Windows
+            # Check the $SHELL env var
+            # and fall back to '/usr/bin/bash'.
+            qmk_env = os.environ.copy()
+            # Set the prompt for the new shell
+            qmk_env['MSYS2_PS1'] = qmk_env['PS1']
+            # Start the new subshell
+            subprocess.run([os.environ.get('SHELL', '/usr/bin/bash')], env=qmk_env)
+    else:
+        cli.log.info("Already within qmk_firmware directory.")
diff --git a/lib/python/qmk/cli/chibios/__init__.py b/lib/python/qmk/cli/chibios/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/chibios/__init__.py
diff --git a/lib/python/qmk/cli/chibios/confmigrate.py b/lib/python/qmk/cli/chibios/confmigrate.py
new file mode 100644
index 0000000000..be1f2cd744
--- /dev/null
+++ b/lib/python/qmk/cli/chibios/confmigrate.py
@@ -0,0 +1,162 @@
+"""This script automates the copying of the default keymap into your own keymap.
+"""
+import re
+import sys
+import os
+
+from qmk.constants import QMK_FIRMWARE
+from qmk.path import normpath
+from milc import cli
+
+
+def eprint(*args, **kwargs):
+    print(*args, file=sys.stderr, **kwargs)
+
+
+file_header = """\
+/* Copyright 2020 QMK
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file was auto-generated by:
+ *    `qmk chibios-confmigrate -i {0} -r {1}`
+ */
+
+#pragma once
+"""
+
+
+def collect_defines(filepath):
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+        define_search = re.compile(r'(?m)^#\s*define\s+(?:.*\\\r?\n)*.*$', re.MULTILINE)
+        value_search = re.compile(r'^#\s*define\s+(?P<name>[a-zA-Z0-9_]+(\([^\)]*\))?)\s*(?P<value>.*)', re.DOTALL)
+        define_matches = define_search.findall(content)
+
+        defines = {"keys": [], "dict": {}}
+        for define_match in define_matches:
+            value_match = value_search.search(define_match)
+            defines["keys"].append(value_match.group("name"))
+            defines["dict"][value_match.group("name")] = value_match.group("value")
+        return defines
+
+
+def check_diffs(input_defs, reference_defs):
+    not_present_in_input = []
+    not_present_in_reference = []
+    to_override = []
+
+    for key in reference_defs["keys"]:
+        if key not in input_defs["dict"]:
+            not_present_in_input.append(key)
+            continue
+
+    for key in input_defs["keys"]:
+        if key not in input_defs["dict"]:
+            not_present_in_input.append(key)
+            continue
+
+    for key in input_defs["keys"]:
+        if key in reference_defs["keys"] and input_defs["dict"][key] != reference_defs["dict"][key]:
+            to_override.append((key, input_defs["dict"][key]))
+
+    return (to_override, not_present_in_input, not_present_in_reference)
+
+
+def migrate_chconf_h(to_override, outfile):
+    print(file_header.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile)
+
+    for override in to_override:
+        print("#define %s %s" % (override[0], override[1]), file=outfile)
+        print("", file=outfile)
+
+    print("#include_next <chconf.h>\n", file=outfile)
+
+
+def migrate_halconf_h(to_override, outfile):
+    print(file_header.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile)
+
+    for override in to_override:
+        print("#define %s %s" % (override[0], override[1]), file=outfile)
+        print("", file=outfile)
+
+    print("#include_next <halconf.h>\n", file=outfile)
+
+
+def migrate_mcuconf_h(to_override, outfile):
+    print(file_header.format(cli.args.input.relative_to(QMK_FIRMWARE), cli.args.reference.relative_to(QMK_FIRMWARE)), file=outfile)
+
+    print("#include_next <mcuconf.h>\n", file=outfile)
+
+    for override in to_override:
+        print("#undef %s" % (override[0]), file=outfile)
+        print("#define %s %s" % (override[0], override[1]), file=outfile)
+        print("", file=outfile)
+
+
+@cli.argument('-i', '--input', type=normpath, arg_only=True, required=True, help='Specify input config file.')
+@cli.argument('-r', '--reference', type=normpath, arg_only=True, required=True, help='Specify the reference file to compare against')
+@cli.argument('-o', '--overwrite', arg_only=True, action='store_true', help='Overwrites the input file during migration.')
+@cli.argument('-d', '--delete', arg_only=True, action='store_true', help='If the file has no overrides, migration will delete the input file.')
+@cli.argument('-f', '--force', arg_only=True, action='store_true', help='Re-migrates an already migrated file, even if it doesn\'t detect a full ChibiOS config.')
+@cli.subcommand('Generates a migrated ChibiOS configuration file, as a result of comparing the input against a reference')
+def chibios_confmigrate(cli):
+    """Generates a usable ChibiOS replacement configuration file, based on a fully-defined conf and a reference config.
+    """
+
+    input_defs = collect_defines(cli.args.input)
+    reference_defs = collect_defines(cli.args.reference)
+
+    (to_override, not_present_in_input, not_present_in_reference) = check_diffs(input_defs, reference_defs)
+
+    if len(not_present_in_input) > 0:
+        eprint("Keys not in input, but present inside reference (potential manual migration required):")
+        for key in not_present_in_input:
+            eprint("   %s" % (key))
+
+    if len(not_present_in_reference) > 0:
+        eprint("Keys not in reference, but present inside input (potential manual migration required):")
+        for key in not_present_in_reference:
+            eprint("   %s" % (key))
+
+    if len(to_override) == 0:
+        eprint('No overrides found! If there were no missing keys above, it should be safe to delete the input file.')
+        if cli.args.delete:
+            os.remove(cli.args.input)
+    else:
+        eprint('Overrides found:')
+        for override in to_override:
+            eprint("%40s: %s -> %s" % (override[0], reference_defs["dict"][override[0]].encode('unicode_escape').decode("utf-8"), override[1].encode('unicode_escape').decode("utf-8")))
+
+        eprint('--------------------------------------')
+
+        if cli.args.input.name == "chconf.h" and ("CHCONF_H" in input_defs["dict"] or "_CHCONF_H_" in input_defs["dict"] or cli.args.force):
+            migrate_chconf_h(to_override, outfile=sys.stdout)
+            if cli.args.overwrite:
+                with open(cli.args.input, "w", encoding='utf-8') as out_file:
+                    migrate_chconf_h(to_override, outfile=out_file)
+
+        elif cli.args.input.name == "halconf.h" and ("HALCONF_H" in input_defs["dict"] or "_HALCONF_H_" in input_defs["dict"] or cli.args.force):
+            migrate_halconf_h(to_override, outfile=sys.stdout)
+            if cli.args.overwrite:
+                with open(cli.args.input, "w", encoding='utf-8') as out_file:
+                    migrate_halconf_h(to_override, outfile=out_file)
+
+        elif cli.args.input.name == "mcuconf.h" and ("MCUCONF_H" in input_defs["dict"] or "_MCUCONF_H_" in input_defs["dict"] or cli.args.force):
+            migrate_mcuconf_h(to_override, outfile=sys.stdout)
+            if cli.args.overwrite:
+                with open(cli.args.input, "w", encoding='utf-8') as out_file:
+                    migrate_mcuconf_h(to_override, outfile=out_file)
diff --git a/lib/python/qmk/cli/ci/__init__.py b/lib/python/qmk/cli/ci/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/ci/__init__.py
diff --git a/lib/python/qmk/cli/ci/validate_aliases.py b/lib/python/qmk/cli/ci/validate_aliases.py
new file mode 100644
index 0000000000..4f2fe6c941
--- /dev/null
+++ b/lib/python/qmk/cli/ci/validate_aliases.py
@@ -0,0 +1,58 @@
+"""Validates the list of keyboard aliases.
+"""
+from milc import cli
+
+from qmk.keyboard import keyboard_folder, keyboard_alias_definitions
+
+
+def _safe_keyboard_folder(target):
+    try:
+        return keyboard_folder(target)  # throws ValueError if it's invalid
+    except Exception:
+        return None
+
+
+def _target_keyboard_exists(target):
+    # If there's no target, then we can't build it.
+    if not target:
+        return False
+
+    # If the target directory exists but it itself has an invalid alias or invalid rules.mk, then we can't build it either.
+    if not _safe_keyboard_folder(target):
+        return False
+
+    # As far as we can tell, we can build it!
+    return True
+
+
+def _alias_not_self(alias):
+    """Check if alias points to itself, either directly or within a circular reference
+    """
+    aliases = keyboard_alias_definitions()
+
+    found = set()
+    while alias in aliases:
+        found.add(alias)
+        alias = aliases[alias].get('target', alias)
+        if alias in found:
+            return False
+
+    return True
+
+
+@cli.subcommand('Validates the list of keyboard aliases.', hidden=True)
+def ci_validate_aliases(cli):
+    aliases = keyboard_alias_definitions()
+
+    success = True
+    for alias in aliases.keys():
+        target = aliases[alias].get('target', None)
+        if not _alias_not_self(alias):
+            cli.log.error(f'Keyboard alias {alias} should not point to itself')
+            success = False
+
+        elif not _target_keyboard_exists(target):
+            cli.log.error(f'Keyboard alias {alias} has a target that doesn\'t exist: {target}')
+            success = False
+
+    return success
diff --git a/lib/python/qmk/cli/clean.py b/lib/python/qmk/cli/clean.py
new file mode 100644
index 0000000000..bdec01e4b6
--- /dev/null
+++ b/lib/python/qmk/cli/clean.py
@@ -0,0 +1,14 @@
+"""Clean the QMK firmware folder of build artifacts.
+"""
+from subprocess import DEVNULL
+
+from qmk.commands import find_make
+from milc import cli
+
+
+@cli.argument('-a', '--all', arg_only=True, action='store_true', help='Remove *.hex and *.bin files in the QMK root as well.')
+@cli.subcommand('Clean the QMK firmware folder of build artifacts.')
+def clean(cli):
+    """Runs `make clean` (or `make distclean` if --all is passed)
+    """
+    cli.run([find_make(), 'distclean' if cli.args.all else 'clean'], capture_output=False, stdin=DEVNULL)
diff --git a/lib/python/qmk/cli/compile.py b/lib/python/qmk/cli/compile.py
new file mode 100755
index 0000000000..8d1195bc8f
--- /dev/null
+++ b/lib/python/qmk/cli/compile.py
@@ -0,0 +1,83 @@
+"""Compile a QMK Firmware.
+
+You can compile a keymap already in the repo or using a QMK Configurator export.
+"""
+from argcomplete.completers import FilesCompleter
+
+from milc import cli
+
+import qmk.path
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.commands import build_environment
+from qmk.keyboard import keyboard_completer, keyboard_folder_or_all, is_all_keyboards
+from qmk.keymap import keymap_completer, locate_keymap
+from qmk.build_targets import KeyboardKeymapBuildTarget, JsonKeymapBuildTarget
+
+
+@cli.argument('filename', nargs='?', arg_only=True, type=qmk.path.FileType('r'), completer=FilesCompleter('.json'), help='The configurator export to compile')
+@cli.argument('-kb', '--keyboard', type=keyboard_folder_or_all, completer=keyboard_completer, help='The keyboard to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't actually build, just show the make command to be run.")
+@cli.argument('-j', '--parallel', type=int, default=1, help="Set the number of parallel make jobs; 0 means unlimited.")
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.")
+@cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.")
+@cli.argument('-t', '--target', type=str, default=None, help="Intended alternative build target, such as `production` in `make planck/rev4:default:production`.")
+@cli.argument('--compiledb', arg_only=True, action='store_true', help="Generates the clang compile_commands.json file during build. Implies --clean.")
+@cli.subcommand('Compile a QMK Firmware.')
+@automagic_keyboard
+@automagic_keymap
+def compile(cli):
+    """Compile a QMK Firmware.
+
+    If a Configurator export is supplied this command will create a new keymap, overwriting an existing keymap if one exists.
+
+    If a keyboard and keymap are provided this command will build a firmware based on that.
+    """
+
+    # If we've received `-kb all`, reroute it to mass-compile.
+    if is_all_keyboards(cli.args.keyboard):
+        from .mass_compile import mass_compile
+        cli.args.builds = []
+        cli.args.filter = []
+        cli.config.mass_compile.keymap = cli.config.compile.keymap
+        cli.config.mass_compile.parallel = cli.config.compile.parallel
+        cli.args.no_temp = False
+        return mass_compile(cli)
+
+    # If we've received `-km all`, reroute it to mass-compile.
+    if cli.args.keymap == 'all':
+        from .mass_compile import mass_compile
+        cli.args.builds = [f'{cli.config.compile.keyboard}:all']
+        cli.args.filter = []
+        cli.config.mass_compile.keymap = None
+        cli.config.mass_compile.parallel = cli.config.compile.parallel
+        cli.args.no_temp = False
+        return mass_compile(cli)
+
+    # Build the environment vars
+    envs = build_environment(cli.args.env)
+
+    # Handler for the build target
+    target = None
+
+    if cli.args.filename:
+        # if we were given a filename, assume we have a json build target
+        target = JsonKeymapBuildTarget(cli.args.filename)
+
+    elif cli.config.compile.keyboard and cli.config.compile.keymap:
+        # if we got a keyboard and keymap, attempt to find it
+        if not locate_keymap(cli.config.compile.keyboard, cli.config.compile.keymap):
+            cli.log.error('Invalid keymap argument.')
+            cli.print_help()
+            return False
+
+        # If we got here, then we have a valid keyboard and keymap for a build target
+        target = KeyboardKeymapBuildTarget(cli.config.compile.keyboard, cli.config.compile.keymap)
+
+    if not target:
+        cli.log.error('You must supply a configurator export, both `--keyboard` and `--keymap`, or be in a directory for a keyboard or keymap.')
+        cli.print_help()
+        return False
+
+    target.configure(parallel=cli.config.compile.parallel, clean=cli.args.clean, compiledb=cli.args.compiledb)
+    return target.compile(cli.args.target, dry_run=cli.args.dry_run, **envs)
diff --git a/lib/python/qmk/cli/docs.py b/lib/python/qmk/cli/docs.py
new file mode 100644
index 0000000000..da02ebf95e
--- /dev/null
+++ b/lib/python/qmk/cli/docs.py
@@ -0,0 +1,30 @@
+"""Serve QMK documentation locally
+"""
+import shutil
+from qmk.docs import prepare_docs_build_area, run_docs_command
+
+from milc import cli
+
+
+@cli.argument('-p', '--port', default=8936, type=int, help='Port number to use.')
+@cli.argument('-b', '--browser', action='store_true', help='Open the docs in the default browser.')
+@cli.subcommand('Run a local webserver for QMK documentation.', hidden=False if cli.config.user.developer else True)
+def docs(cli):
+    """Spin up a local HTTP server for the QMK docs.
+    """
+
+    if not shutil.which('doxygen'):
+        cli.log.error('doxygen is not installed. Please install it and try again.')
+        return
+
+    if not shutil.which('yarn'):
+        cli.log.error('yarn is not installed. Please install it and try again.')
+        return
+
+    if not prepare_docs_build_area(is_production=False):
+        return False
+
+    cmd = ['docs:dev', '--port', f'{cli.args.port}']
+    if cli.args.browser:
+        cmd.append('--open')
+    run_docs_command('run', cmd)
diff --git a/lib/python/qmk/cli/doctor/__init__.py b/lib/python/qmk/cli/doctor/__init__.py
new file mode 100755
index 0000000000..272e042023
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/__init__.py
@@ -0,0 +1,5 @@
+"""QMK Doctor
+
+Check out the user's QMK environment and make sure it's ready to compile.
+"""
+from .main import doctor
diff --git a/lib/python/qmk/cli/doctor/check.py b/lib/python/qmk/cli/doctor/check.py
new file mode 100644
index 0000000000..a717bcb591
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/check.py
@@ -0,0 +1,285 @@
+"""Check for specific programs.
+"""
+from enum import Enum
+import shutil
+from subprocess import DEVNULL, TimeoutExpired
+from tempfile import TemporaryDirectory
+from pathlib import Path
+
+from milc import cli
+from qmk import submodules
+from qmk.commands import find_make
+
+
+class CheckStatus(Enum):
+    OK = 1
+    WARNING = 2
+    ERROR = 3
+
+
+WHICH_MAKE = Path(find_make()).name
+
+ESSENTIAL_BINARIES = {
+    WHICH_MAKE: {},
+    'git': {},
+    'dos2unix': {},
+    'diff': {},
+    'dfu-programmer': {},
+    'avrdude': {},
+    'dfu-util': {},
+    'avr-gcc': {
+        'version_arg': '-dumpversion'
+    },
+    'arm-none-eabi-gcc': {
+        'version_arg': '-dumpversion'
+    },
+}
+
+
+def _check_make_version():
+    last_line = ESSENTIAL_BINARIES[WHICH_MAKE]['output'].split('\n')[0]
+    version_number = last_line.split()[2]
+    cli.log.info('Found %s version %s', WHICH_MAKE, version_number)
+
+    return CheckStatus.OK
+
+
+def _check_git_version():
+    last_line = ESSENTIAL_BINARIES['git']['output'].split('\n')[0]
+    version_number = last_line.split()[2]
+    cli.log.info('Found git version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def _check_dos2unix_version():
+    last_line = ESSENTIAL_BINARIES['dos2unix']['output'].split('\n')[0]
+    version_number = last_line.split()[1]
+    cli.log.info('Found dos2unix version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def _check_diff_version():
+    last_line = ESSENTIAL_BINARIES['diff']['output'].split('\n')[0]
+    if 'Apple diff' in last_line:
+        version_number = last_line
+    else:
+        version_number = last_line.split()[3]
+    cli.log.info('Found diff version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def _check_arm_gcc_version():
+    """Returns True if the arm-none-eabi-gcc version is not known to cause problems.
+    """
+    version_number = ESSENTIAL_BINARIES['arm-none-eabi-gcc']['output'].strip()
+    cli.log.info('Found arm-none-eabi-gcc version %s', version_number)
+
+    # Right now all known ARM versions are ok, so check that it can produce binaries
+    return _check_arm_gcc_installation()
+
+
+def _check_arm_gcc_installation():
+    """Returns OK if the arm-none-eabi-gcc is fully installed and can produce binaries.
+    """
+    with TemporaryDirectory() as temp_dir:
+        temp_in = Path(temp_dir) / 'test.c'
+        temp_out = Path(temp_dir) / 'test.elf'
+
+        temp_in.write_text('#include <newlib.h>\nint main() { return __NEWLIB__ * __NEWLIB_MINOR__ * __NEWLIB_PATCHLEVEL__; }', encoding='utf-8')
+
+        args = ['arm-none-eabi-gcc', '-mcpu=cortex-m0', '-mthumb', '-mno-thumb-interwork', '--specs=nosys.specs', '--specs=nano.specs', '-x', 'c', '-o', str(temp_out), str(temp_in)]
+        result = cli.run(args, stdout=None, stderr=None)
+        if result.returncode == 0:
+            cli.log.info('Successfully compiled using arm-none-eabi-gcc')
+        else:
+            cli.log.error(f'Failed to compile a simple program with arm-none-eabi-gcc, return code {result.returncode}')
+            cli.log.error(f'Command: {" ".join(args)}')
+            return CheckStatus.ERROR
+
+        args = ['arm-none-eabi-size', str(temp_out)]
+        result = cli.run(args, stdout=None, stderr=None)
+        if result.returncode == 0:
+            cli.log.info('Successfully tested arm-none-eabi-binutils using arm-none-eabi-size')
+        else:
+            cli.log.error(f'Failed to execute arm-none-eabi-size, perhaps corrupt arm-none-eabi-binutils, return code {result.returncode}')
+            cli.log.error(f'Command: {" ".join(args)}')
+            return CheckStatus.ERROR
+
+        return CheckStatus.OK
+
+
+def _check_avr_gcc_version():
+    """Returns True if the avr-gcc version is not known to cause problems.
+    """
+    version_number = ESSENTIAL_BINARIES['avr-gcc']['output'].strip()
+    cli.log.info('Found avr-gcc version %s', version_number)
+
+    # Right now all known AVR versions are ok, so check that it can produce binaries
+    return _check_avr_gcc_installation()
+
+
+def _check_avr_gcc_installation():
+    """Returns OK if the avr-gcc is fully installed and can produce binaries.
+    """
+    with TemporaryDirectory() as temp_dir:
+        temp_in = Path(temp_dir) / 'test.c'
+        temp_out = Path(temp_dir) / 'test.elf'
+
+        temp_in.write_text('int main() { return 0; }', encoding='utf-8')
+
+        args = ['avr-gcc', '-mmcu=atmega32u4', '-x', 'c', '-o', str(temp_out), str(temp_in)]
+        result = cli.run(args, stdout=None, stderr=None)
+        if result.returncode == 0:
+            cli.log.info('Successfully compiled using avr-gcc')
+        else:
+            cli.log.error(f'Failed to compile a simple program with avr-gcc, return code {result.returncode}')
+            cli.log.error(f'Command: {" ".join(args)}')
+            return CheckStatus.ERROR
+
+        args = ['avr-size', str(temp_out)]
+        result = cli.run(args, stdout=None, stderr=None)
+        if result.returncode == 0:
+            cli.log.info('Successfully tested avr-binutils using avr-size')
+        else:
+            cli.log.error(f'Failed to execute avr-size, perhaps corrupt avr-binutils, return code {result.returncode}')
+            cli.log.error(f'Command: {" ".join(args)}')
+            return CheckStatus.ERROR
+
+        return CheckStatus.OK
+
+
+def _check_avrdude_version():
+    lines = ESSENTIAL_BINARIES['avrdude']['output'].split('\n')
+    # avrdude version text is currently not translated, however we fall back to old behaviour of assuming a line
+    version_line = next((line for line in lines if 'version' in line), lines[-2])
+    version_number = version_line.split()[2][:-1]
+    cli.log.info('Found avrdude version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def _check_dfu_util_version():
+    first_line = ESSENTIAL_BINARIES['dfu-util']['output'].split('\n')[0]
+    version_number = first_line.split()[1]
+    cli.log.info('Found dfu-util version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def _check_dfu_programmer_version():
+    first_line = ESSENTIAL_BINARIES['dfu-programmer']['output'].split('\n')[0]
+    version_number = first_line.split()[1]
+    cli.log.info('Found dfu-programmer version %s', version_number)
+
+    return CheckStatus.OK
+
+
+def check_binaries():
+    """Iterates through ESSENTIAL_BINARIES and tests them.
+    """
+    ok = CheckStatus.OK
+    missing_from_path = []
+
+    for binary in sorted(ESSENTIAL_BINARIES):
+        try:
+            if not is_in_path(binary):
+                ok = CheckStatus.ERROR
+                missing_from_path.append(binary)
+            elif not is_executable(binary):
+                ok = CheckStatus.ERROR
+        except TimeoutExpired:
+            cli.log.debug('Timeout checking %s', binary)
+            if ok != CheckStatus.ERROR:
+                ok = CheckStatus.WARNING
+
+    if missing_from_path:
+        location_noun = 'its location' if len(missing_from_path) == 1 else 'their locations'
+        cli.log.error('{fg_red}' + ', '.join(missing_from_path) + f' may need to be installed, or {location_noun} added to your path.')
+
+    return ok
+
+
+def check_binary_versions():
+    """Check the versions of ESSENTIAL_BINARIES
+    """
+    checks = {
+        WHICH_MAKE: _check_make_version,
+        'git': _check_git_version,
+        'dos2unix': _check_dos2unix_version,
+        'diff': _check_diff_version,
+        'arm-none-eabi-gcc': _check_arm_gcc_version,
+        'avr-gcc': _check_avr_gcc_version,
+        'avrdude': _check_avrdude_version,
+        'dfu-util': _check_dfu_util_version,
+        'dfu-programmer': _check_dfu_programmer_version,
+    }
+
+    versions = []
+    for binary in sorted(ESSENTIAL_BINARIES):
+        if 'output' not in ESSENTIAL_BINARIES[binary]:
+            cli.log.warning('Unknown version for %s', binary)
+            versions.append(CheckStatus.WARNING)
+            continue
+
+        check = checks[binary]
+        versions.append(check())
+    return versions
+
+
+def check_submodules():
+    """Iterates through all submodules to make sure they're cloned and up to date.
+    """
+    for submodule in submodules.status().values():
+        if submodule['status'] is None:
+            return CheckStatus.ERROR
+        elif not submodule['status']:
+            return CheckStatus.WARNING
+
+    return CheckStatus.OK
+
+
+def is_in_path(command):
+    """Returns True if command is found in the path.
+    """
+    if shutil.which(command) is None:
+        cli.log.error("{fg_red}Can't find %s in your path.", command)
+        return False
+    return True
+
+
+def is_executable(command):
+    """Returns True if command can be executed.
+    """
+    # Make sure the command can be executed
+    version_arg = ESSENTIAL_BINARIES[command].get('version_arg', '--version')
+    check = cli.run([command, version_arg], combined_output=True, stdin=DEVNULL, timeout=5)
+
+    ESSENTIAL_BINARIES[command]['output'] = check.stdout
+
+    if check.returncode in [0, 1]:  # Older versions of dfu-programmer exit 1
+        cli.log.debug('Found {fg_cyan}%s', command)
+        return True
+
+    cli.log.error("{fg_red}Can't run `%s %s`", command, version_arg)
+    return False
+
+
+def release_info(file='/etc/os-release'):
+    """Parse release info to dict
+    """
+    ret = {}
+    try:
+        with open(file) as f:
+            for line in f:
+                if '=' in line:
+                    key, value = map(str.strip, line.split('=', 1))
+                    if value.startswith('"') and value.endswith('"'):
+                        value = value[1:-1]
+                    ret[key] = value
+    except (PermissionError, FileNotFoundError):
+        pass
+
+    return ret
diff --git a/lib/python/qmk/cli/doctor/linux.py b/lib/python/qmk/cli/doctor/linux.py
new file mode 100644
index 0000000000..c99cc6baea
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/linux.py
@@ -0,0 +1,155 @@
+"""OS-specific functions for: Linux
+"""
+import platform
+import shutil
+from pathlib import Path
+
+from milc import cli
+
+from qmk.constants import QMK_FIRMWARE, BOOTLOADER_VIDS_PIDS
+from .check import CheckStatus, release_info
+
+
+def _is_wsl():
+    return 'microsoft' in platform.uname().release.lower()
+
+
+def _udev_rule(vid, pid=None, *args):
+    """ Helper function that return udev rules
+    """
+    rule = ""
+    if pid:
+        rule = 'SUBSYSTEMS=="usb", ATTRS{idVendor}=="%s", ATTRS{idProduct}=="%s", TAG+="uaccess"' % (
+            vid,
+            pid,
+        )
+    else:
+        rule = 'SUBSYSTEMS=="usb", ATTRS{idVendor}=="%s", TAG+="uaccess"' % vid
+    if args:
+        rule = ', '.join([rule, *args])
+    return rule
+
+
+def _generate_desired_rules(bootloader_vids_pids):
+    rules = dict()
+    for bl in bootloader_vids_pids.keys():
+        rules[bl] = set()
+        for vid_pid in bootloader_vids_pids[bl]:
+            if bl == 'caterina' or bl == 'md-boot':
+                rules[bl].add(_udev_rule(vid_pid[0], vid_pid[1], 'ENV{ID_MM_DEVICE_IGNORE}="1"'))
+            else:
+                rules[bl].add(_udev_rule(vid_pid[0], vid_pid[1]))
+    return rules
+
+
+def _deprecated_udev_rule(vid, pid=None):
+    """ Helper function that return udev rules
+
+    Note: these are no longer the recommended rules, this is just used to check for them
+    """
+    if pid:
+        return 'SUBSYSTEMS=="usb", ATTRS{idVendor}=="%s", ATTRS{idProduct}=="%s", MODE:="0666"' % (vid, pid)
+    else:
+        return 'SUBSYSTEMS=="usb", ATTRS{idVendor}=="%s", MODE:="0666"' % vid
+
+
+def check_udev_rules():
+    """Make sure the udev rules look good.
+    """
+    rc = CheckStatus.OK
+    udev_dirs = [
+        Path("/usr/lib/udev/rules.d/"),
+        Path("/usr/local/lib/udev/rules.d/"),
+        Path("/run/udev/rules.d/"),
+        Path("/etc/udev/rules.d/"),
+    ]
+
+    desired_rules = _generate_desired_rules(BOOTLOADER_VIDS_PIDS)
+
+    # These rules are no longer recommended, only use them to check for their presence.
+    deprecated_rules = {
+        'atmel-dfu': {_deprecated_udev_rule("03eb", "2ff4"), _deprecated_udev_rule("03eb", "2ffb"), _deprecated_udev_rule("03eb", "2ff0")},
+        'kiibohd': {_deprecated_udev_rule("1c11")},
+        'stm32': {_deprecated_udev_rule("1eaf", "0003"), _deprecated_udev_rule("0483", "df11")},
+        'bootloadhid': {_deprecated_udev_rule("16c0", "05df")},
+        'caterina': {'ATTRS{idVendor}=="2a03", ENV{ID_MM_DEVICE_IGNORE}="1"', 'ATTRS{idVendor}=="2341", ENV{ID_MM_DEVICE_IGNORE}="1"'},
+        'tmk': {_deprecated_udev_rule("feed")}
+    }
+
+    if any(udev_dir.exists() for udev_dir in udev_dirs):
+        udev_rules = [rule_file for udev_dir in udev_dirs for rule_file in udev_dir.glob('*.rules')]
+        current_rules = set()
+
+        # Collect all rules from the config files
+        for rule_file in udev_rules:
+            try:
+                for line in rule_file.read_text(encoding='utf-8').split('\n'):
+                    line = line.strip()
+                    if not line.startswith("#") and len(line):
+                        current_rules.add(line)
+            except (PermissionError, FileNotFoundError):
+                cli.log.debug("Failed to read: %s", rule_file)
+
+        # Check if the desired rules are among the currently present rules
+        for bootloader, rules in desired_rules.items():
+            if not rules.issubset(current_rules):
+                deprecated_rule = deprecated_rules.get(bootloader)
+                if deprecated_rule and deprecated_rule.issubset(current_rules):
+                    cli.log.warning("{fg_yellow}Found old, deprecated udev rules for '%s' boards. The new rules on https://docs.qmk.fm/#/faq_build?id=linux-udev-rules offer better security with the same functionality.", bootloader)
+                else:
+                    # For caterina, check if ModemManager is running
+                    if bootloader == "caterina" and check_modem_manager():
+                        cli.log.warning("{fg_yellow}Detected ModemManager without the necessary udev rules. Please either disable it or set the appropriate udev rules if you are using a Pro Micro.")
+
+                    rc = CheckStatus.WARNING
+                    cli.log.warning("{fg_yellow}Missing or outdated udev rules for '%s' boards. Run 'sudo cp %s/util/udev/50-qmk.rules /etc/udev/rules.d/'.", bootloader, QMK_FIRMWARE)
+
+    else:
+        cli.log.warning("{fg_yellow}Can't find udev rules, skipping udev rule checking...")
+        cli.log.debug("Checked directories: %s", ', '.join(str(udev_dir) for udev_dir in udev_dirs))
+
+    return rc
+
+
+def check_systemd():
+    """Check if it's a systemd system
+    """
+    return bool(shutil.which("systemctl"))
+
+
+def check_modem_manager():
+    """Returns True if ModemManager is running.
+
+    """
+    if check_systemd():
+        mm_check = cli.run(["systemctl", "--quiet", "is-active", "ModemManager.service"], timeout=10)
+        if mm_check.returncode == 0:
+            return True
+    else:
+        """(TODO): Add check for non-systemd systems
+        """
+    return False
+
+
+def os_test_linux():
+    """Run the Linux specific tests.
+    """
+    info = release_info()
+    release_id = info.get('PRETTY_NAME', info.get('ID', 'Unknown'))
+    plat = 'WSL, ' if _is_wsl() else ''
+
+    cli.log.info(f"Detected {{fg_cyan}}Linux ({plat}{release_id}){{fg_reset}}.")
+
+    # Don't bother with udev on WSL, for now
+    if _is_wsl():
+        # https://github.com/microsoft/WSL/issues/4197
+        if QMK_FIRMWARE.as_posix().startswith("/mnt"):
+            cli.log.warning("I/O performance on /mnt may be extremely slow.")
+            return CheckStatus.WARNING
+
+    else:
+        rc = check_udev_rules()
+        if rc != CheckStatus.OK:
+            return rc
+
+    return CheckStatus.OK
diff --git a/lib/python/qmk/cli/doctor/macos.py b/lib/python/qmk/cli/doctor/macos.py
new file mode 100644
index 0000000000..5d088c9492
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/macos.py
@@ -0,0 +1,13 @@
+import platform
+
+from milc import cli
+
+from .check import CheckStatus
+
+
+def os_test_macos():
+    """Run the Mac specific tests.
+    """
+    cli.log.info("Detected {fg_cyan}macOS %s (%s){fg_reset}.", platform.mac_ver()[0], 'Apple Silicon' if platform.processor() == 'arm' else 'Intel')
+
+    return CheckStatus.OK
diff --git a/lib/python/qmk/cli/doctor/main.py b/lib/python/qmk/cli/doctor/main.py
new file mode 100755
index 0000000000..45667e8ce2
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/main.py
@@ -0,0 +1,240 @@
+"""QMK Doctor
+
+Check out the user's QMK environment and make sure it's ready to compile.
+"""
+import platform
+
+from milc import cli
+from milc.questions import yesno
+
+from qmk import submodules
+from qmk.constants import QMK_FIRMWARE, QMK_FIRMWARE_UPSTREAM, QMK_USERSPACE, HAS_QMK_USERSPACE
+from .check import CheckStatus, check_binaries, check_binary_versions, check_submodules
+from qmk.git import git_check_repo, git_get_branch, git_get_tag, git_get_last_log_entry, git_get_common_ancestor, git_is_dirty, git_get_remotes, git_check_deviation
+from qmk.commands import in_virtualenv
+from qmk.userspace import qmk_userspace_paths, qmk_userspace_validate, UserspaceValidationError
+
+
+def distrib_tests():
+    def _load_kvp_file(file):
+        """Load a simple key=value file into a dictionary
+        """
+        vars = {}
+        with open(file, 'r') as f:
+            for line in f:
+                if '=' in line:
+                    key, value = line.split('=', 1)
+                    vars[key.strip()] = value.strip()
+        return vars
+
+    def _parse_toolchain_release_file(file):
+        """Parse the QMK toolchain release info file
+        """
+        try:
+            vars = _load_kvp_file(file)
+            return f'{vars.get("TOOLCHAIN_HOST", "unknown")}:{vars.get("TOOLCHAIN_TARGET", "unknown")}:{vars.get("COMMIT_HASH", "unknown")}'
+        except Exception as e:
+            cli.log.warning('Error reading QMK toolchain release info file: %s', e)
+            return f'Unknown toolchain release info file: {file}'
+
+    def _parse_flashutils_release_file(file):
+        """Parse the QMK flashutils release info file
+        """
+        try:
+            vars = _load_kvp_file(file)
+            return f'{vars.get("FLASHUTILS_HOST", "unknown")}:{vars.get("COMMIT_HASH", "unknown")}'
+        except Exception as e:
+            cli.log.warning('Error reading QMK flashutils release info file: %s', e)
+            return f'Unknown flashutils release info file: {file}'
+
+    try:
+        from qmk.cli import QMK_DISTRIB_DIR
+        if (QMK_DISTRIB_DIR / 'etc').exists():
+            cli.log.info('Found QMK tools distribution directory: {fg_cyan}%s', QMK_DISTRIB_DIR)
+
+            toolchains = [_parse_toolchain_release_file(file) for file in (QMK_DISTRIB_DIR / 'etc').glob('toolchain_release_*')]
+            if len(toolchains) > 0:
+                cli.log.info('Found QMK toolchains: {fg_cyan}%s', ', '.join(toolchains))
+            else:
+                cli.log.warning('No QMK toolchains manifest found.')
+
+            flashutils = [_parse_flashutils_release_file(file) for file in (QMK_DISTRIB_DIR / 'etc').glob('flashutils_release_*')]
+            if len(flashutils) > 0:
+                cli.log.info('Found QMK flashutils: {fg_cyan}%s', ', '.join(flashutils))
+            else:
+                cli.log.warning('No QMK flashutils manifest found.')
+    except ImportError:
+        cli.log.info('QMK tools distribution not found.')
+
+    return CheckStatus.OK
+
+
+def os_tests():
+    """Determine our OS and run platform specific tests
+    """
+    platform_id = platform.platform().lower()
+
+    if 'darwin' in platform_id or 'macos' in platform_id:
+        from .macos import os_test_macos
+        return os_test_macos()
+    elif 'linux' in platform_id:
+        from .linux import os_test_linux
+        return os_test_linux()
+    elif 'windows' in platform_id:
+        from .windows import os_test_windows
+        return os_test_windows()
+    else:
+        cli.log.warning('Unsupported OS detected: %s', platform_id)
+        return CheckStatus.WARNING
+
+
+def git_tests():
+    """Run Git-related checks
+    """
+    status = CheckStatus.OK
+
+    # Make sure our QMK home is a Git repo
+    git_ok = git_check_repo()
+    if not git_ok:
+        cli.log.warning("{fg_yellow}QMK home does not appear to be a Git repository! (no .git folder)")
+        status = CheckStatus.WARNING
+    else:
+        git_branch = git_get_branch()
+        if git_branch:
+            cli.log.info('Git branch: %s', git_branch)
+
+            repo_version = git_get_tag()
+            if repo_version:
+                cli.log.info('Repo version: %s', repo_version)
+
+            git_dirty = git_is_dirty()
+            if git_dirty:
+                cli.log.warning('{fg_yellow}Git has unstashed/uncommitted changes.')
+                status = CheckStatus.WARNING
+            git_remotes = git_get_remotes()
+            if 'upstream' not in git_remotes.keys() or QMK_FIRMWARE_UPSTREAM not in git_remotes['upstream'].get('url', ''):
+                cli.log.warning('{fg_yellow}The official repository does not seem to be configured as git remote "upstream".')
+                status = CheckStatus.WARNING
+            else:
+                git_deviation = git_check_deviation(git_branch)
+                if git_branch in ['master', 'develop'] and git_deviation:
+                    cli.log.warning('{fg_yellow}The local "%s" branch contains commits not found in the upstream branch.', git_branch)
+                    status = CheckStatus.WARNING
+                for branch in [git_branch, 'upstream/master', 'upstream/develop']:
+                    cli.log.info('- Latest %s: %s', branch, git_get_last_log_entry(branch))
+                for branch in ['upstream/master', 'upstream/develop']:
+                    cli.log.info('- Common ancestor with %s: %s', branch, git_get_common_ancestor(branch, 'HEAD'))
+
+    return status
+
+
+def output_submodule_status():
+    """Prints out information related to the submodule status.
+    """
+    cli.log.info('Submodule status:')
+    sub_status = submodules.status()
+    for s in sub_status.keys():
+        sub_info = sub_status[s]
+        if 'name' in sub_info:
+            sub_name = sub_info['name']
+            sub_shorthash = sub_info['shorthash'] if 'shorthash' in sub_info else ''
+            sub_describe = sub_info['describe'] if 'describe' in sub_info else ''
+            sub_last_log_timestamp = sub_info['last_log_timestamp'] if 'last_log_timestamp' in sub_info else ''
+            if sub_last_log_timestamp != '':
+                cli.log.info(f'- {sub_name}: {sub_last_log_timestamp} -- {sub_describe} ({sub_shorthash})')
+            else:
+                cli.log.error(f'- {sub_name}: <<< missing or unknown >>>')
+
+
+def userspace_tests(qmk_firmware):
+    if qmk_firmware:
+        cli.log.info(f'QMK home: {{fg_cyan}}{qmk_firmware}')
+
+    for path in qmk_userspace_paths():
+        try:
+            qmk_userspace_validate(path)
+            cli.log.info(f'Testing userspace candidate: {{fg_cyan}}{path}{{fg_reset}} -- {{fg_green}}Valid `qmk.json`')
+        except FileNotFoundError:
+            cli.log.warning(f'Testing userspace candidate: {{fg_cyan}}{path}{{fg_reset}} -- {{fg_red}}Missing `qmk.json`')
+        except UserspaceValidationError as err:
+            cli.log.warning(f'Testing userspace candidate: {{fg_cyan}}{path}{{fg_reset}} -- {{fg_red}}Invalid `qmk.json`')
+            cli.log.warning(f' -- {{fg_cyan}}{path}/qmk.json{{fg_reset}} validation error: {err}')
+
+    if QMK_USERSPACE is not None:
+        cli.log.info(f'QMK userspace: {{fg_cyan}}{QMK_USERSPACE}')
+    cli.log.info(f'Userspace enabled: {{fg_cyan}}{HAS_QMK_USERSPACE}')
+
+
+@cli.argument('-y', '--yes', action='store_true', arg_only=True, help='Answer yes to all questions.')
+@cli.argument('-n', '--no', action='store_true', arg_only=True, help='Answer no to all questions.')
+@cli.subcommand('Basic QMK environment checks')
+def doctor(cli):
+    """Basic QMK environment checks.
+
+    This is currently very simple, it just checks that all the expected binaries are on your system.
+
+    TODO(unclaimed):
+        * [ ] Compile a trivial program with each compiler
+    """
+    cli.log.info('QMK Doctor is checking your environment.')
+    cli.log.info('Python version: %s', platform.python_version())
+    cli.log.info('CLI version: %s', cli.version)
+    cli.log.info('QMK home: {fg_cyan}%s', QMK_FIRMWARE)
+
+    status = os_status = os_tests()
+    distrib_tests()
+
+    userspace_tests(None)
+
+    git_status = git_tests()
+
+    if git_status == CheckStatus.ERROR or (os_status == CheckStatus.OK and git_status == CheckStatus.WARNING):
+        status = git_status
+
+    if in_virtualenv():
+        cli.log.info('CLI installed in virtualenv.')
+
+    # Make sure the basic CLI tools we need are available and can be executed.
+    bin_ok = check_binaries()
+    if bin_ok == CheckStatus.OK:
+        cli.log.info('All dependencies are installed.')
+    elif bin_ok == CheckStatus.WARNING:
+        cli.log.warning('Issues encountered while checking dependencies.')
+    else:
+        status = CheckStatus.ERROR
+
+    # Make sure the tools are at the correct version
+    ver_ok = check_binary_versions()
+    if CheckStatus.ERROR in ver_ok:
+        status = CheckStatus.ERROR
+    elif CheckStatus.WARNING in ver_ok and status == CheckStatus.OK:
+        status = CheckStatus.WARNING
+
+    # Check out the QMK submodules
+    sub_ok = check_submodules()
+    if sub_ok == CheckStatus.OK:
+        cli.log.info('Submodules are up to date.')
+    else:
+        if git_check_repo() and yesno('Would you like to clone the submodules?', default=True):
+            submodules.update()
+            sub_ok = check_submodules()
+
+        if sub_ok == CheckStatus.ERROR:
+            status = CheckStatus.ERROR
+        elif sub_ok == CheckStatus.WARNING and status == CheckStatus.OK:
+            status = CheckStatus.WARNING
+
+    output_submodule_status()
+
+    # Report a summary of our findings to the user
+    if status == CheckStatus.OK:
+        cli.log.info('{fg_green}QMK is ready to go')
+        return 0
+    elif status == CheckStatus.WARNING:
+        cli.log.info('{fg_yellow}QMK is ready to go, but minor problems were found')
+        return 1
+    else:
+        cli.log.info('{fg_red}Major problems detected, please fix these problems before proceeding.{fg_reset}')
+        cli.log.info('{fg_blue}If you\'re missing dependencies, try following the instructions on: https://docs.qmk.fm/newbs_getting_started{fg_reset}')
+        cli.log.info('{fg_blue}Additionally, check out the FAQ (https://docs.qmk.fm/#/faq_build) or join the QMK Discord (https://discord.gg/qmk) for help.{fg_reset}')
+        return 2
diff --git a/lib/python/qmk/cli/doctor/windows.py b/lib/python/qmk/cli/doctor/windows.py
new file mode 100644
index 0000000000..26bb65374b
--- /dev/null
+++ b/lib/python/qmk/cli/doctor/windows.py
@@ -0,0 +1,20 @@
+import platform
+
+from milc import cli
+
+from .check import CheckStatus, release_info
+
+
+def os_test_windows():
+    """Run the Windows specific tests.
+    """
+    win32_ver = platform.win32_ver()
+    cli.log.info("Detected {fg_cyan}Windows %s (%s){fg_reset}.", win32_ver[0], win32_ver[1])
+
+    # MSYS really does not like "/" files - resolve manually
+    file = cli.run(['cygpath', '-m', '/etc/qmk-release']).stdout.strip()
+    qmk_distro_version = release_info(file).get('VERSION', None)
+    if qmk_distro_version:
+        cli.log.info('QMK MSYS version: %s', qmk_distro_version)
+
+    return CheckStatus.OK
diff --git a/lib/python/qmk/cli/find.py b/lib/python/qmk/cli/find.py
new file mode 100644
index 0000000000..7d8b1b066c
--- /dev/null
+++ b/lib/python/qmk/cli/find.py
@@ -0,0 +1,32 @@
+"""Command to search through all keyboards and keymaps for a given search criteria.
+"""
+import os
+from milc import cli
+from qmk.search import filter_help, search_keymap_targets
+from qmk.util import maybe_exit_config
+
+
+@cli.argument(
+    '-f',
+    '--filter',
+    arg_only=True,
+    action='append',
+    default=[],
+    help=  # noqa: `format-python` and `pytest` don't agree here.
+    f"Filter the list of keyboards based on their info.json data. Accepts the formats key=value, function(key), or function(key,value), eg. 'features.rgblight=true'. Valid functions are {filter_help()}. May be passed multiple times; all filters need to match. Value may include wildcards such as '*' and '?'."  # noqa: `format-python` and `pytest` don't agree here.
+)
+@cli.argument('-p', '--print', arg_only=True, action='append', default=[], help="For each matched target, print the value of the supplied info.json key. May be passed multiple times.")
+@cli.argument('-km', '--keymap', type=str, default='default', help="The keymap name to build. Default is 'default'.")
+@cli.subcommand('Find builds which match supplied search criteria.')
+def find(cli):
+    """Search through all keyboards and keymaps for a given search criteria.
+    """
+    os.environ.setdefault('SKIP_SCHEMA_VALIDATION', '1')
+    maybe_exit_config(should_exit=False, should_reraise=True)
+
+    targets = search_keymap_targets([('all', cli.config.find.keymap)], cli.args.filter)
+    for target in sorted(targets, key=lambda t: (t.keyboard, t.keymap)):
+        print(f'{target}')
+
+        for key in cli.args.print:
+            print(f'    {key}={target.dotty.get(key, None)}')
diff --git a/lib/python/qmk/cli/flash.py b/lib/python/qmk/cli/flash.py
new file mode 100644
index 0000000000..c570b49ebe
--- /dev/null
+++ b/lib/python/qmk/cli/flash.py
@@ -0,0 +1,116 @@
+"""Compile and flash QMK Firmware
+
+You can compile a keymap already in the repo or using a QMK Configurator export.
+A bootloader must be specified.
+"""
+from argcomplete.completers import FilesCompleter
+from pathlib import Path
+
+from milc import cli
+
+import qmk.path
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.commands import build_environment
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.keymap import keymap_completer, locate_keymap
+from qmk.flashers import flasher
+from qmk.build_targets import KeyboardKeymapBuildTarget, JsonKeymapBuildTarget
+
+
+def _list_bootloaders():
+    """Prints the available bootloaders listed in docs.qmk.fm.
+    """
+    cli.print_help()
+    cli.log.info('Here are the available bootloaders:')
+    cli.echo('\tavrdude')
+    cli.echo('\tbootloadhid')
+    cli.echo('\tdfu')
+    cli.echo('\tdfu-util')
+    cli.echo('\tmdloader')
+    cli.echo('\tst-flash')
+    cli.echo('\tst-link-cli')
+    cli.log.info('Enhanced variants for split keyboards:')
+    cli.echo('\tavrdude-split-left')
+    cli.echo('\tavrdude-split-right')
+    cli.echo('\tdfu-ee')
+    cli.echo('\tdfu-split-left')
+    cli.echo('\tdfu-split-right')
+    cli.echo('\tdfu-util-split-left')
+    cli.echo('\tdfu-util-split-right')
+    cli.echo('\tuf2-split-left')
+    cli.echo('\tuf2-split-right')
+    cli.echo('For more info, visit https://docs.qmk.fm/#/flashing')
+    return False
+
+
+def _flash_binary(filename, mcu):
+    """Try to flash binary firmware
+    """
+    cli.echo('Flashing binary firmware...\nPlease reset your keyboard into bootloader mode now!\nPress Ctrl-C to exit.\n')
+    try:
+        err, msg = flasher(mcu, filename)
+        if err:
+            cli.log.error(msg)
+            return False
+    except KeyboardInterrupt:
+        cli.log.info('Ctrl-C was pressed, exiting...')
+    return True
+
+
+@cli.argument('filename', nargs='?', arg_only=True, type=qmk.path.FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON to be compiled and flashed or a pre-compiled binary firmware file (bin/hex) to be flashed.')
+@cli.argument('-b', '--bootloaders', action='store_true', help='List the available bootloaders.')
+@cli.argument('-bl', '--bootloader', default='flash', help='The flash command, corresponding to qmk\'s make options of bootloaders.')
+@cli.argument('-m', '--mcu', help='The MCU name. Required for HalfKay, HID, USBAspLoader and ISP flashing.')
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='The keyboard to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't actually build, just show the make command to be run.")
+@cli.argument('-j', '--parallel', type=int, default=1, help="Set the number of parallel make jobs; 0 means unlimited.")
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.")
+@cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.")
+@cli.subcommand('QMK Flash.')
+@automagic_keyboard
+@automagic_keymap
+def flash(cli):
+    """Compile and or flash QMK Firmware or keyboard/layout
+
+    If a binary firmware is supplied, try to flash that.
+
+    If a Configurator export is supplied this command will create a new keymap, overwriting an existing keymap if one exists.
+
+    If a keyboard and keymap are provided this command will build a firmware based on that.
+
+    If bootloader is omitted the make system will use the configured bootloader for that keyboard.
+    """
+    if cli.args.filename and isinstance(cli.args.filename, Path) and cli.args.filename.suffix in ['.bin', '.hex', '.uf2']:
+        return _flash_binary(cli.args.filename, cli.args.mcu)
+
+    if cli.args.bootloaders:
+        return _list_bootloaders()
+
+    # Build the environment vars
+    envs = build_environment(cli.args.env)
+
+    # Handler for the build target
+    target = None
+
+    if cli.args.filename:
+        # if we were given a filename, assume we have a json build target
+        target = JsonKeymapBuildTarget(cli.args.filename)
+
+    elif cli.config.flash.keyboard and cli.config.flash.keymap:
+        # if we got a keyboard and keymap, attempt to find it
+        if not locate_keymap(cli.config.flash.keyboard, cli.config.flash.keymap):
+            cli.log.error('Invalid keymap argument.')
+            cli.print_help()
+            return False
+
+        # If we got here, then we have a valid keyboard and keymap for a build target
+        target = KeyboardKeymapBuildTarget(cli.config.flash.keyboard, cli.config.flash.keymap)
+
+    if not target:
+        cli.log.error('You must supply a configurator export, both `--keyboard` and `--keymap`, or be in a directory for a keyboard or keymap.')
+        cli.print_help()
+        return False
+
+    target.configure(parallel=cli.config.flash.parallel, clean=cli.args.clean)
+    return target.compile(cli.args.bootloader, dry_run=cli.args.dry_run, **envs)
diff --git a/lib/python/qmk/cli/format/__init__.py b/lib/python/qmk/cli/format/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/format/__init__.py
diff --git a/lib/python/qmk/cli/format/c.py b/lib/python/qmk/cli/format/c.py
new file mode 100644
index 0000000000..65818155b0
--- /dev/null
+++ b/lib/python/qmk/cli/format/c.py
@@ -0,0 +1,138 @@
+"""Format C code according to QMK's style.
+"""
+from shutil import which
+from subprocess import CalledProcessError, DEVNULL, Popen, PIPE
+
+from argcomplete.completers import FilesCompleter
+from milc import cli
+
+from qmk.path import normpath
+from qmk.c_parse import c_source_files
+
+c_file_suffixes = ('c', 'h', 'cpp', 'hpp')
+core_dirs = ('drivers', 'quantum', 'tests', 'tmk_core', 'platforms', 'modules')
+ignored = ('tmk_core/protocol/usb_hid', 'platforms/chibios/boards')
+
+
+def is_relative_to(file, other):
+    """Provide similar behavior to PurePath.is_relative_to in Python > 3.9
+    """
+    return str(normpath(file).resolve()).startswith(str(normpath(other).resolve()))
+
+
+def find_clang_format():
+    """Returns the path to clang-format.
+    """
+    for clang_version in range(20, 6, -1):
+        binary = f'clang-format-{clang_version}'
+
+        if which(binary):
+            return binary
+
+    return 'clang-format'
+
+
+def find_diffs(files):
+    """Run clang-format and diff it against a file.
+    """
+    found_diffs = False
+
+    for file in files:
+        cli.log.debug('Checking for changes in %s', file)
+        clang_format = Popen([find_clang_format(), file], stdout=PIPE, stderr=PIPE, universal_newlines=True)
+        diff = cli.run(['diff', '-u', f'--label=a/{file}', f'--label=b/{file}', str(file), '-'], stdin=clang_format.stdout, capture_output=True)
+
+        if diff.returncode != 0:
+            print(diff.stdout)
+            found_diffs = True
+
+    return found_diffs
+
+
+def cformat_run(files):
+    """Spawn clang-format subprocess with proper arguments
+    """
+    # Determine which version of clang-format to use
+    clang_format = [find_clang_format(), '-i']
+
+    try:
+        cli.run([*clang_format, *map(str, files)], check=True, capture_output=False, stdin=DEVNULL)
+        cli.log.info('Successfully formatted the C code.')
+        return True
+
+    except CalledProcessError as e:
+        cli.log.error('Error formatting C code!')
+        cli.log.debug('%s exited with returncode %s', e.cmd, e.returncode)
+        cli.log.debug('STDOUT:')
+        cli.log.debug(e.stdout)
+        cli.log.debug('STDERR:')
+        cli.log.debug(e.stderr)
+        return False
+
+
+def filter_files(files, core_only=False):
+    """Yield only files to be formatted and skip the rest
+    """
+    files = list(map(normpath, filter(None, files)))
+
+    for file in files:
+        if core_only:
+            # The following statement checks each file to see if the file path is
+            # - in the core directories
+            # - not in the ignored directories
+            if not any(is_relative_to(file, i) for i in core_dirs) or any(is_relative_to(file, i) for i in ignored):
+                cli.log.debug("Skipping non-core file %s, as '--core-only' is used.", file)
+                continue
+
+        if file.suffix[1:] in c_file_suffixes:
+            yield file
+        else:
+            cli.log.debug('Skipping file %s', file)
+
+
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Flag only, don't automatically format.")
+@cli.argument('-b', '--base-branch', default='origin/master', help='Branch to compare to diffs to.')
+@cli.argument('-a', '--all-files', arg_only=True, action='store_true', help='Format all core files.')
+@cli.argument('--core-only', arg_only=True, action='store_true', help='Format core files only.')
+@cli.argument('files', nargs='*', arg_only=True, type=normpath, completer=FilesCompleter('.c'), help='Filename(s) to format.')
+@cli.subcommand("Format C code according to QMK's style.", hidden=False if cli.config.user.developer else True)
+def format_c(cli):
+    """Format C code according to QMK's style.
+    """
+    # Find the list of files to format
+    if cli.args.files:
+        files = list(filter_files(cli.args.files, cli.args.core_only))
+
+        if not files:
+            cli.log.error('No C files in filelist: %s', ', '.join(map(str, cli.args.files)))
+            exit(0)
+
+        if cli.args.all_files:
+            cli.log.warning('Filenames passed with -a, only formatting: %s', ','.join(map(str, files)))
+
+    elif cli.args.all_files:
+        all_files = c_source_files(core_dirs)
+        files = list(filter_files(all_files, True))
+
+    else:
+        git_diff_cmd = ['git', 'diff', '--name-only', cli.args.base_branch, *core_dirs]
+        git_diff = cli.run(git_diff_cmd, stdin=DEVNULL)
+
+        if git_diff.returncode != 0:
+            cli.log.error("Error running %s", git_diff_cmd)
+            print(git_diff.stderr)
+            return git_diff.returncode
+
+        changed_files = git_diff.stdout.strip().split('\n')
+        files = list(filter_files(changed_files, True))
+
+    # Sanity check
+    if not files:
+        cli.log.error('No changed files detected. Use "qmk format-c -a" to format all core files')
+        return False
+
+    # Run clang-format on the files we've found
+    if cli.args.dry_run:
+        return not find_diffs(files)
+    else:
+        return cformat_run(files)
diff --git a/lib/python/qmk/cli/format/json.py b/lib/python/qmk/cli/format/json.py
new file mode 100755
index 0000000000..61f5254184
--- /dev/null
+++ b/lib/python/qmk/cli/format/json.py
@@ -0,0 +1,118 @@
+"""JSON Formatting Script
+
+Spits out a JSON file formatted with one of QMK's formatters.
+"""
+import json
+
+from jsonschema import ValidationError
+from milc import cli
+
+from qmk.info import info_json
+from qmk.json_schema import json_load, validate
+from qmk.json_encoders import InfoJSONEncoder, KeymapJSONEncoder, UserspaceJSONEncoder, CommunityModuleJSONEncoder
+from qmk.path import normpath
+
+
+def _detect_json_format(file, json_data):
+    """Detect the format of a json file.
+    """
+    json_encoder = None
+    try:
+        validate(json_data, 'qmk.user_repo.v1_1')
+        json_encoder = UserspaceJSONEncoder
+    except ValidationError:
+        pass
+
+    if json_encoder is None:
+        try:
+            validate(json_data, 'qmk.user_repo.v1')
+            json_encoder = UserspaceJSONEncoder
+        except ValidationError:
+            pass
+
+    if json_encoder is None:
+        try:
+            validate(json_data, 'qmk.community_module.v1')
+            json_encoder = CommunityModuleJSONEncoder
+        except ValidationError:
+            pass
+
+    if json_encoder is None:
+        try:
+            validate(json_data, 'qmk.keyboard.v1')
+            json_encoder = InfoJSONEncoder
+        except ValidationError as e:
+            cli.log.warning('File %s did not validate as a keyboard info.json or userspace qmk.json:\n\t%s', file, e)
+            cli.log.info('Treating %s as a keymap file.', file)
+            json_encoder = KeymapJSONEncoder
+
+    return json_encoder
+
+
+def _get_json_encoder(file, json_data):
+    """Get the json encoder for a file.
+    """
+    json_encoder = None
+    if cli.args.format == 'auto':
+        json_encoder = _detect_json_format(file, json_data)
+    elif cli.args.format == 'keyboard':
+        json_encoder = InfoJSONEncoder
+    elif cli.args.format == 'keymap':
+        json_encoder = KeymapJSONEncoder
+    elif cli.args.format == 'userspace':
+        json_encoder = UserspaceJSONEncoder
+    elif cli.args.format == 'community_module':
+        json_encoder = CommunityModuleJSONEncoder
+    else:
+        # This should be impossible
+        cli.log.error('Unknown format: %s', cli.args.format)
+    return json_encoder
+
+
+@cli.argument('json_file', arg_only=True, type=normpath, help='JSON file to format')
+@cli.argument('-f', '--format', choices=['auto', 'keyboard', 'keymap', 'userspace', 'community_module'], default='auto', arg_only=True, help='JSON formatter to use (Default: autodetect)')
+@cli.argument('-i', '--inplace', action='store_true', arg_only=True, help='If set, will operate in-place on the input file')
+@cli.argument('-p', '--print', action='store_true', arg_only=True, help='If set, will print the formatted json to stdout ')
+@cli.subcommand('Generate an info.json file for a keyboard.', hidden=False if cli.config.user.developer else True)
+def format_json(cli):
+    """Format a json file.
+    """
+    json_data = json_load(cli.args.json_file)
+
+    json_encoder = _get_json_encoder(cli.args.json_file, json_data)
+    if json_encoder is None:
+        return False
+
+    if json_encoder == KeymapJSONEncoder and 'layout' in json_data:
+        # Attempt to format the keycodes.
+        layout = json_data['layout']
+        info_data = info_json(json_data['keyboard'])
+
+        if layout in info_data.get('layout_aliases', {}):
+            layout = json_data['layout'] = info_data['layout_aliases'][layout]
+
+        if layout in info_data.get('layouts'):
+            for layer_num, layer in enumerate(json_data['layers']):
+                current_layer = []
+                last_row = 0
+
+                for keymap_key, info_key in zip(layer, info_data['layouts'][layout]['layout']):
+                    if last_row != info_key['y']:
+                        current_layer.append('JSON_NEWLINE')
+                        last_row = info_key['y']
+
+                    current_layer.append(keymap_key)
+
+                json_data['layers'][layer_num] = current_layer
+
+    output = json.dumps(json_data, cls=json_encoder, sort_keys=True)
+
+    if cli.args.inplace:
+        with open(cli.args.json_file, 'w+', encoding='utf-8', newline='\n') as outfile:
+            outfile.write(output + '\n')
+
+    # Display the results if print was set
+    # We don't operate in-place by default, so also display to stdout
+    # if in-place is not set.
+    if cli.args.print or not cli.args.inplace:
+        print(output)
diff --git a/lib/python/qmk/cli/format/python.py b/lib/python/qmk/cli/format/python.py
new file mode 100755
index 0000000000..e7b545109f
--- /dev/null
+++ b/lib/python/qmk/cli/format/python.py
@@ -0,0 +1,70 @@
+"""Format python code according to QMK's style.
+"""
+from subprocess import CalledProcessError, DEVNULL
+
+from milc import cli
+
+from qmk.path import normpath
+
+py_file_suffixes = ('py',)
+py_dirs = ['lib/python', 'util/ci']
+
+
+def yapf_run(files):
+    edit = '--diff' if cli.args.dry_run else '--in-place'
+    yapf_cmd = ['yapf', '-vv', '--recursive', edit, *files]
+    try:
+        cli.run(yapf_cmd, check=True, capture_output=False, stdin=DEVNULL)
+        cli.log.info('Successfully formatted the python code.')
+
+    except CalledProcessError:
+        cli.log.error(f'Python code in {",".join(py_dirs)} incorrectly formatted!')
+        return False
+
+
+def filter_files(files):
+    """Yield only files to be formatted and skip the rest
+    """
+    files = list(map(normpath, filter(None, files)))
+    for file in files:
+        if file.suffix[1:] in py_file_suffixes:
+            yield file
+        else:
+            cli.log.debug('Skipping file %s', file)
+
+
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't actually format.")
+@cli.argument('-b', '--base-branch', default='origin/master', help='Branch to compare to diffs to.')
+@cli.argument('-a', '--all-files', arg_only=True, action='store_true', help='Format all files.')
+@cli.argument('files', nargs='*', arg_only=True, type=normpath, help='Filename(s) to format.')
+@cli.subcommand("Format python code according to QMK's style.", hidden=False if cli.config.user.developer else True)
+def format_python(cli):
+    """Format python code according to QMK's style.
+    """
+    # Find the list of files to format
+    if cli.args.files:
+        files = list(filter_files(cli.args.files))
+
+        if not files:
+            cli.log.error('No Python files in filelist: %s', ', '.join(map(str, cli.args.files)))
+            exit(0)
+
+        if cli.args.all_files:
+            cli.log.warning('Filenames passed with -a, only formatting: %s', ','.join(map(str, files)))
+
+    elif cli.args.all_files:
+        git_ls_cmd = ['git', 'ls-files', *py_dirs]
+        git_ls = cli.run(git_ls_cmd, stdin=DEVNULL)
+        files = list(filter_files(git_ls.stdout.split('\n')))
+
+    else:
+        git_diff_cmd = ['git', 'diff', '--name-only', cli.args.base_branch, *py_dirs]
+        git_diff = cli.run(git_diff_cmd, stdin=DEVNULL)
+        files = list(filter_files(git_diff.stdout.split('\n')))
+
+    # Sanity check
+    if not files:
+        cli.log.error('No changed files detected. Use "qmk format-python -a" to format all files')
+        return False
+
+    return yapf_run(files)
diff --git a/lib/python/qmk/cli/format/text.py b/lib/python/qmk/cli/format/text.py
new file mode 100644
index 0000000000..344631081b
--- /dev/null
+++ b/lib/python/qmk/cli/format/text.py
@@ -0,0 +1,57 @@
+"""Ensure text files have the proper line endings.
+"""
+from itertools import islice
+from subprocess import DEVNULL
+
+from milc import cli
+
+from qmk.path import normpath
+
+
+def _get_chunks(it, size):
+    """Break down a collection into smaller parts
+    """
+    it = iter(it)
+    return iter(lambda: tuple(islice(it, size)), ())
+
+
+def dos2unix_run(files):
+    """Spawn multiple dos2unix subprocess avoiding too long commands on formatting everything
+    """
+    for chunk in _get_chunks([normpath(file).as_posix() for file in files], 10):
+        dos2unix = cli.run(['dos2unix', *chunk])
+
+        if dos2unix.returncode:
+            return False
+
+
+@cli.argument('-b', '--base-branch', default='origin/master', help='Branch to compare to diffs to.')
+@cli.argument('-a', '--all-files', arg_only=True, action='store_true', help='Format all files.')
+@cli.argument('files', nargs='*', arg_only=True, type=normpath, help='Filename(s) to format.')
+@cli.subcommand("Ensure text files have the proper line endings.", hidden=True)
+def format_text(cli):
+    """Ensure text files have the proper line endings.
+    """
+    # Find the list of files to format
+    if cli.args.files:
+        files = list(cli.args.files)
+
+        if cli.args.all_files:
+            cli.log.warning('Filenames passed with -a, only formatting: %s', ','.join(map(str, files)))
+
+    elif cli.args.all_files:
+        git_ls_cmd = ['git', 'ls-files']
+        git_ls = cli.run(git_ls_cmd, stdin=DEVNULL)
+        files = list(filter(None, git_ls.stdout.split('\n')))
+
+    else:
+        git_diff_cmd = ['git', 'diff', '--name-only', cli.args.base_branch]
+        git_diff = cli.run(git_diff_cmd, stdin=DEVNULL)
+        files = list(filter(None, git_diff.stdout.split('\n')))
+
+    # Sanity check
+    if not files:
+        cli.log.error('No changed files detected. Use "qmk format-text -a" to format all files')
+        return False
+
+    return dos2unix_run(files)
diff --git a/lib/python/qmk/cli/generate/__init__.py b/lib/python/qmk/cli/generate/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/generate/__init__.py
diff --git a/lib/python/qmk/cli/generate/api.py b/lib/python/qmk/cli/generate/api.py
new file mode 100755
index 0000000000..7f7c05f6e2
--- /dev/null
+++ b/lib/python/qmk/cli/generate/api.py
@@ -0,0 +1,204 @@
+"""This script automates the generation of the QMK API data.
+"""
+from pathlib import Path
+import shutil
+import json
+
+from milc import cli
+
+import qmk.path
+from qmk.datetime import current_datetime
+from qmk.info import info_json
+from qmk.json_schema import json_load
+from qmk.keymap import list_keymaps
+from qmk.keyboard import find_readme, list_keyboards, keyboard_alias_definitions
+from qmk.keycodes import load_spec, list_versions, list_languages
+
+DATA_PATH = Path('data')
+TEMPLATE_PATH = DATA_PATH / 'templates/api/'
+BUILD_API_PATH = Path('.build/api_data/')
+
+
+def _list_constants(output_folder):
+    """Produce a map of available constants
+    """
+    ret = {}
+    for file in (output_folder / 'constants').glob('**/*_[0-9].[0-9].[0-9].json'):
+        name, version = file.stem.rsplit('_', 1)
+        if name not in ret:
+            ret[name] = []
+        ret[name].append(version)
+
+    # Ensure content is sorted
+    for name in ret:
+        ret[name] = sorted(ret[name])
+
+    return ret
+
+
+def _resolve_keycode_specs(output_folder):
+    """To make it easier for consumers, publish pre-merged spec files
+    """
+    for version in list_versions():
+        overall = load_spec(version)
+
+        output_file = output_folder / f'constants/keycodes_{version}.json'
+        output_file.write_text(json.dumps(overall, separators=(',', ':')), encoding='utf-8')
+
+    for lang in list_languages():
+        for version in list_versions(lang):
+            overall = load_spec(version, lang)
+
+            output_file = output_folder / f'constants/keycodes_{lang}_{version}.json'
+            output_file.write_text(json.dumps(overall, separators=(',', ':')), encoding='utf-8')
+
+    # Purge files consumed by 'load_spec'
+    shutil.rmtree(output_folder / 'constants/keycodes/')
+
+
+def _filtered_copy(src, dst):
+    src = Path(src)
+    dst = Path(dst)
+
+    if dst.suffix == '.hjson':
+        data = json_load(src)
+
+        dst = dst.with_suffix('.json')
+        dst.write_text(json.dumps(data, separators=(',', ':')), encoding='utf-8')
+        return dst
+
+    if dst.suffix == '.jsonschema':
+        data = json_load(src)
+
+        dst.write_text(json.dumps(data), encoding='utf-8')
+        return dst
+
+    return shutil.copy2(src, dst)
+
+
+def _filtered_keyboard_list():
+    """Perform basic filtering of list_keyboards
+    """
+    keyboard_list = list_keyboards()
+    if cli.args.filter:
+        kb_list = []
+        for keyboard_name in keyboard_list:
+            if any(i in keyboard_name for i in cli.args.filter):
+                kb_list.append(keyboard_name)
+        keyboard_list = kb_list
+    return keyboard_list
+
+
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't write the data to disk.")
+@cli.argument('-f', '--filter', arg_only=True, action='append', default=[], help="Filter the list of keyboards based on partial name matches the supplied value. May be passed multiple times.")
+@cli.subcommand('Generate QMK API data', hidden=False if cli.config.user.developer else True)
+def generate_api(cli):
+    """Generates the QMK API data.
+    """
+    v1_dir = BUILD_API_PATH / 'v1'
+    keyboard_all_file = v1_dir / 'keyboards.json'  # A massive JSON containing everything
+    keyboard_list_file = v1_dir / 'keyboard_list.json'  # A simple list of keyboard targets
+    keyboard_aliases_file = v1_dir / 'keyboard_aliases.json'  # A list of historical keyboard names and their new name
+    keyboard_metadata_file = v1_dir / 'keyboard_metadata.json'  # All the data configurator/via needs for initialization
+    constants_metadata_file = v1_dir / 'constants_metadata.json'  # Metadata for available constants
+    usb_file = v1_dir / 'usb.json'  # A mapping of USB VID/PID -> keyboard target
+
+    if BUILD_API_PATH.exists():
+        shutil.rmtree(BUILD_API_PATH)
+
+    shutil.copytree(TEMPLATE_PATH, BUILD_API_PATH)
+    shutil.copytree(DATA_PATH, v1_dir, copy_function=_filtered_copy)
+
+    # Filter down when required
+    keyboard_list = _filtered_keyboard_list()
+
+    kb_all = {}
+    usb_list = {}
+
+    # Generate and write keyboard specific JSON files
+    for keyboard_name in keyboard_list:
+        kb_json = info_json(keyboard_name)
+        kb_all[keyboard_name] = kb_json
+
+        keyboard_dir = v1_dir / 'keyboards' / keyboard_name
+        keyboard_info = keyboard_dir / 'info.json'
+        keyboard_readme = keyboard_dir / 'readme.md'
+        keyboard_readme_src = find_readme(keyboard_name)
+
+        # Populate the list of JSON keymaps
+        for keymap in list_keymaps(keyboard_name, c=False, fullpath=True):
+            keymap_rel = qmk.path.under_qmk_firmware(keymap)
+            if keymap_rel is None:
+                cli.log.debug('Skipping keymap %s (not in qmk_firmware)', keymap)
+                continue
+
+            if (keymap_rel / 'keymap.c').exists():
+                cli.log.debug('Skipping keymap %s (not pure dd keymap)', keymap)
+                continue
+
+            kb_json['keymaps'][keymap.name] = {
+                # TODO: deprecate 'url' as consumer needs to know its potentially hjson
+                'url': f'https://raw.githubusercontent.com/qmk/qmk_firmware/master/{keymap_rel}/keymap.json',
+
+                # Instead consumer should grab from API and not repo directly
+                'path': (keymap_rel / 'keymap.json').as_posix(),
+            }
+
+        keyboard_dir.mkdir(parents=True, exist_ok=True)
+        keyboard_json = json.dumps({'last_updated': current_datetime(), 'keyboards': {keyboard_name: kb_json}}, separators=(',', ':'))
+        if not cli.args.dry_run:
+            keyboard_info.write_text(keyboard_json, encoding='utf-8')
+            cli.log.debug('Wrote file %s', keyboard_info)
+
+            if keyboard_readme_src:
+                shutil.copyfile(keyboard_readme_src, keyboard_readme)
+                cli.log.debug('Copied %s -> %s', keyboard_readme_src, keyboard_readme)
+
+            # resolve keymaps as json
+            for keymap in kb_json['keymaps']:
+                keymap_hjson = kb_json['keymaps'][keymap]['path']
+                keymap_json = v1_dir / keymap_hjson
+                keymap_json.parent.mkdir(parents=True, exist_ok=True)
+                keymap_json.write_text(json.dumps(json_load(Path(keymap_hjson)), separators=(',', ':')), encoding='utf-8')
+                cli.log.debug('Wrote keymap %s', keymap_json)
+
+        if 'usb' in kb_json:
+            usb = kb_json['usb']
+
+            if 'vid' in usb and usb['vid'] not in usb_list:
+                usb_list[usb['vid']] = {}
+
+            if 'pid' in usb and usb['pid'] not in usb_list[usb['vid']]:
+                usb_list[usb['vid']][usb['pid']] = {}
+
+            if 'vid' in usb and 'pid' in usb:
+                usb_list[usb['vid']][usb['pid']][keyboard_name] = usb
+
+    # Generate data for the global files
+    keyboard_list = sorted(kb_all)
+    keyboard_aliases = keyboard_alias_definitions()
+    keyboard_metadata = {
+        'last_updated': current_datetime(),
+        'keyboards': keyboard_list,
+        'keyboard_aliases': keyboard_aliases,
+        'usb': usb_list,
+    }
+
+    # Feature specific handling
+    _resolve_keycode_specs(v1_dir)
+
+    # Write the global JSON files
+    keyboard_all_json = json.dumps({'last_updated': current_datetime(), 'keyboards': kb_all}, separators=(',', ':'))
+    usb_json = json.dumps({'last_updated': current_datetime(), 'usb': usb_list}, separators=(',', ':'))
+    keyboard_list_json = json.dumps({'last_updated': current_datetime(), 'keyboards': keyboard_list}, separators=(',', ':'))
+    keyboard_aliases_json = json.dumps({'last_updated': current_datetime(), 'keyboard_aliases': keyboard_aliases}, separators=(',', ':'))
+    keyboard_metadata_json = json.dumps(keyboard_metadata, separators=(',', ':'))
+    constants_metadata_json = json.dumps({'last_updated': current_datetime(), 'constants': _list_constants(v1_dir)}, separators=(',', ':'))
+
+    if not cli.args.dry_run:
+        keyboard_all_file.write_text(keyboard_all_json, encoding='utf-8')
+        usb_file.write_text(usb_json, encoding='utf-8')
+        keyboard_list_file.write_text(keyboard_list_json, encoding='utf-8')
+        keyboard_aliases_file.write_text(keyboard_aliases_json, encoding='utf-8')
+        keyboard_metadata_file.write_text(keyboard_metadata_json, encoding='utf-8')
+        constants_metadata_file.write_text(constants_metadata_json, encoding='utf-8')
diff --git a/lib/python/qmk/cli/generate/autocorrect_data.py b/lib/python/qmk/cli/generate/autocorrect_data.py
new file mode 100644
index 0000000000..4f322adce2
--- /dev/null
+++ b/lib/python/qmk/cli/generate/autocorrect_data.py
@@ -0,0 +1,291 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Python program to make autocorrect_data.h.
+This program reads from a prepared dictionary file and generates a C source file
+"autocorrect_data.h" with a serialized trie embedded as an array. Run this
+program and pass it as the first argument like:
+$ qmk generate-autocorrect-data autocorrect_dict.txt
+Each line of the dict file defines one typo and its correction with the syntax
+"typo -> correction". Blank lines or lines starting with '#' are ignored.
+Example:
+  :thier        -> their
+  fitler        -> filter
+  lenght        -> length
+  ouput         -> output
+  widht         -> width
+For full documentation, see QMK Docs
+"""
+
+import textwrap
+from typing import Any, Dict, Iterator, List, Tuple
+
+from milc import cli
+
+from qmk.commands import dump_lines
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.keymap import keymap_completer, locate_keymap
+from qmk.path import normpath
+from qmk.util import maybe_exit
+
+KC_A = 4
+KC_SPC = 0x2c
+KC_QUOT = 0x34
+
+TYPO_CHARS = dict([
+    ("'", KC_QUOT),
+    (':', KC_SPC),  # "Word break" character.
+] + [(chr(c), c + KC_A - ord('a')) for c in range(ord('a'),
+                                                  ord('z') + 1)])  # Characters a-z.
+
+
+def parse_file(file_name: str) -> List[Tuple[str, str]]:
+    """Parses autocorrections dictionary file.
+  Each line of the file defines one typo and its correction with the syntax
+  "typo -> correction". Blank lines or lines starting with '#' are ignored. The
+  function validates that typos only have characters a-z and that typos are not
+  substrings of other typos, otherwise the longer typo would never trigger.
+  Args:
+    file_name: String, path of the autocorrections dictionary.
+  Returns:
+    List of (typo, correction) tuples.
+  """
+
+    try:
+        import english_words
+        correct_words = english_words.get_english_words_set(['web2'], lower=True, alpha=True)
+    except AttributeError:
+        from english_words import english_words_lower_alpha_set as correct_words
+        if not cli.args.quiet:
+            cli.echo('The english_words package is outdated, update by running:')
+            cli.echo('  {fg_cyan}python3 -m pip install english_words --upgrade')
+    except ImportError:
+        if not cli.args.quiet:
+            cli.echo('Autocorrection will falsely trigger when a typo is a substring of a correctly spelled word.')
+            cli.echo('To check for this, install the english_words package and rerun this script:')
+            cli.echo('  {fg_cyan}python3 -m pip install english_words')
+        # Use a minimal word list as a fallback.
+        correct_words = ('information', 'available', 'international', 'language', 'loosest', 'reference', 'wealthier', 'entertainment', 'association', 'provides', 'technology', 'statehood')
+
+    autocorrections = []
+    typos = set()
+    for line_number, typo, correction in parse_file_lines(file_name):
+        if typo in typos:
+            cli.log.warning('{fg_red}Error:%d:{fg_reset} Ignoring duplicate typo: "{fg_cyan}%s{fg_reset}"', line_number, typo)
+            continue
+
+        # Check that `typo` is valid.
+        if not (all([c in TYPO_CHARS for c in typo])):
+            cli.log.error('{fg_red}Error:%d:{fg_reset} Typo "{fg_cyan}%s{fg_reset}" has characters other than a-z, \' and :.', line_number, typo)
+            maybe_exit(1)
+        for other_typo in typos:
+            if typo in other_typo or other_typo in typo:
+                cli.log.error('{fg_red}Error:%d:{fg_reset} Typos may not be substrings of one another, otherwise the longer typo would never trigger: "{fg_cyan}%s{fg_reset}" vs. "{fg_cyan}%s{fg_reset}".', line_number, typo, other_typo)
+                maybe_exit(1)
+        if len(typo) < 5:
+            cli.log.warning('{fg_yellow}Warning:%d:{fg_reset} It is suggested that typos are at least 5 characters long to avoid false triggers: "{fg_cyan}%s{fg_reset}"', line_number, typo)
+        if len(typo) > 127:
+            cli.log.error('{fg_red}Error:%d:{fg_reset} Typo exceeds 127 chars: "{fg_cyan}%s{fg_reset}"', line_number, typo)
+            maybe_exit(1)
+
+        check_typo_against_dictionary(typo, line_number, correct_words)
+
+        autocorrections.append((typo, correction))
+        typos.add(typo)
+
+    return autocorrections
+
+
+def make_trie(autocorrections: List[Tuple[str, str]]) -> Dict[str, Any]:
+    """Makes a trie from the the typos, writing in reverse.
+  Args:
+    autocorrections: List of (typo, correction) tuples.
+  Returns:
+    Dict of dict, representing the trie.
+  """
+    trie = {}
+    for typo, correction in autocorrections:
+        node = trie
+        for letter in typo[::-1]:
+            node = node.setdefault(letter, {})
+        node['LEAF'] = (typo, correction)
+
+    return trie
+
+
+def parse_file_lines(file_name: str) -> Iterator[Tuple[int, str, str]]:
+    """Parses lines read from `file_name` into typo-correction pairs."""
+
+    line_number = 0
+    for line in open(file_name, 'rt'):
+        line_number += 1
+        line = line.strip()
+        if line and line[0] != '#':
+            # Parse syntax "typo -> correction", using strip to ignore indenting.
+            tokens = [token.strip() for token in line.split('->', 1)]
+            if len(tokens) != 2 or not tokens[0]:
+                print(f'Error:{line_number}: Invalid syntax: "{line}"')
+                maybe_exit(1)
+
+            typo, correction = tokens
+            typo = typo.lower()  # Force typos to lowercase.
+            typo = typo.replace(' ', ':')
+
+            yield line_number, typo, correction
+
+
+def check_typo_against_dictionary(typo: str, line_number: int, correct_words) -> None:
+    """Checks `typo` against English dictionary words."""
+
+    if typo.startswith(':') and typo.endswith(':'):
+        if typo[1:-1] in correct_words:
+            cli.log.warning('{fg_yellow}Warning:%d:{fg_reset} Typo "{fg_cyan}%s{fg_reset}" is a correctly spelled dictionary word.', line_number, typo)
+    elif typo.startswith(':') and not typo.endswith(':'):
+        for word in correct_words:
+            if word.startswith(typo[1:]):
+                cli.log.warning('{fg_yellow}Warning:%d: {fg_reset}Typo "{fg_cyan}%s{fg_reset}" would falsely trigger on correctly spelled word "{fg_cyan}%s{fg_reset}".', line_number, typo, word)
+    elif not typo.startswith(':') and typo.endswith(':'):
+        for word in correct_words:
+            if word.endswith(typo[:-1]):
+                cli.log.warning('{fg_yellow}Warning:%d:{fg_reset} Typo "{fg_cyan}%s{fg_reset}" would falsely trigger on correctly spelled word "{fg_cyan}%s{fg_reset}".', line_number, typo, word)
+    elif not typo.startswith(':') and not typo.endswith(':'):
+        for word in correct_words:
+            if typo in word:
+                cli.log.warning('{fg_yellow}Warning:%d:{fg_reset} Typo "{fg_cyan}%s{fg_reset}" would falsely trigger on correctly spelled word "{fg_cyan}%s{fg_reset}".', line_number, typo, word)
+
+
+def serialize_trie(autocorrections: List[Tuple[str, str]], trie: Dict[str, Any]) -> List[int]:
+    """Serializes trie and correction data in a form readable by the C code.
+  Args:
+    autocorrections: List of (typo, correction) tuples.
+    trie: Dict of dicts.
+  Returns:
+    List of ints in the range 0-255.
+  """
+    table = []
+
+    # Traverse trie in depth first order.
+    def traverse(trie_node):
+        if 'LEAF' in trie_node:  # Handle a leaf trie node.
+            typo, correction = trie_node['LEAF']
+            word_boundary_ending = typo[-1] == ':'
+            typo = typo.strip(':')
+            i = 0  # Make the autocorrection data for this entry and serialize it.
+            while i < min(len(typo), len(correction)) and typo[i] == correction[i]:
+                i += 1
+            backspaces = len(typo) - i - 1 + word_boundary_ending
+            assert 0 <= backspaces <= 63
+            correction = correction[i:]
+            bs_count = [backspaces + 128]
+            data = bs_count + list(bytes(correction, 'ascii')) + [0]
+
+            entry = {'data': data, 'links': [], 'byte_offset': 0}
+            table.append(entry)
+        elif len(trie_node) == 1:  # Handle trie node with a single child.
+            c, trie_node = next(iter(trie_node.items()))
+            entry = {'chars': c, 'byte_offset': 0}
+
+            # It's common for a trie to have long chains of single-child nodes. We
+            # find the whole chain so that we can serialize it more efficiently.
+            while len(trie_node) == 1 and 'LEAF' not in trie_node:
+                c, trie_node = next(iter(trie_node.items()))
+                entry['chars'] += c
+
+            table.append(entry)
+            entry['links'] = [traverse(trie_node)]
+        else:  # Handle trie node with multiple children.
+            entry = {'chars': ''.join(sorted(trie_node.keys())), 'byte_offset': 0}
+            table.append(entry)
+            entry['links'] = [traverse(trie_node[c]) for c in entry['chars']]
+        return entry
+
+    traverse(trie)
+
+    def serialize(e: Dict[str, Any]) -> List[int]:
+        if not e['links']:  # Handle a leaf table entry.
+            return e['data']
+        elif len(e['links']) == 1:  # Handle a chain table entry.
+            return [TYPO_CHARS[c] for c in e['chars']] + [0]  # + encode_link(e['links'][0]))
+        else:  # Handle a branch table entry.
+            data = []
+            for c, link in zip(e['chars'], e['links']):
+                data += [TYPO_CHARS[c] | (0 if data else 64)] + encode_link(link)
+            return data + [0]
+
+    byte_offset = 0
+    for e in table:  # To encode links, first compute byte offset of each entry.
+        e['byte_offset'] = byte_offset
+        byte_offset += len(serialize(e))
+        assert 0 <= byte_offset <= 0xffff
+
+    return [b for e in table for b in serialize(e)]  # Serialize final table.
+
+
+def encode_link(link: Dict[str, Any]) -> List[int]:
+    """Encodes a node link as two bytes."""
+    byte_offset = link['byte_offset']
+    if not (0 <= byte_offset <= 0xffff):
+        cli.log.error('{fg_red}Error:{fg_reset} The autocorrection table is too large, a node link exceeds 64KB limit. Try reducing the autocorrection dict to fewer entries.')
+        maybe_exit(1)
+    return [byte_offset & 255, byte_offset >> 8]
+
+
+def typo_len(e: Tuple[str, str]) -> int:
+    return len(e[0])
+
+
+def to_hex(b: int) -> str:
+    return f'0x{b:02X}'
+
+
+@cli.argument('filename', type=normpath, help='The autocorrection database file')
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='The keyboard to build a firmware for. Ignored when a output file is supplied.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a output file is supplied.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.subcommand('Generate the autocorrection data file from a dictionary file.')
+def generate_autocorrect_data(cli):
+    autocorrections = parse_file(cli.args.filename)
+    trie = make_trie(autocorrections)
+    data = serialize_trie(autocorrections, trie)
+
+    current_keyboard = cli.args.keyboard or cli.config.user.keyboard or cli.config.generate_autocorrect_data.keyboard
+    current_keymap = cli.args.keymap or cli.config.user.keymap or cli.config.generate_autocorrect_data.keymap
+
+    if not cli.args.output and current_keyboard and current_keymap:
+        cli.args.output = locate_keymap(current_keyboard, current_keymap).parent / 'autocorrect_data.h'
+
+    assert all(0 <= b <= 255 for b in data)
+
+    min_typo = min(autocorrections, key=typo_len)[0]
+    max_typo = max(autocorrections, key=typo_len)[0]
+
+    # Build the autocorrect_data.h file.
+    autocorrect_data_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '']
+
+    autocorrect_data_h_lines.append(f'// Autocorrection dictionary ({len(autocorrections)} entries):')
+    for typo, correction in autocorrections:
+        autocorrect_data_h_lines.append(f'//   {typo:<{len(max_typo)}} -> {correction}')
+
+    autocorrect_data_h_lines.append('')
+    autocorrect_data_h_lines.append(f'#define AUTOCORRECT_MIN_LENGTH {len(min_typo)} // "{min_typo}"')
+    autocorrect_data_h_lines.append(f'#define AUTOCORRECT_MAX_LENGTH {len(max_typo)} // "{max_typo}"')
+    autocorrect_data_h_lines.append(f'#define DICTIONARY_SIZE {len(data)}')
+    autocorrect_data_h_lines.append('')
+    autocorrect_data_h_lines.append('static const uint8_t autocorrect_data[DICTIONARY_SIZE] PROGMEM = {')
+    autocorrect_data_h_lines.append(textwrap.fill('    %s' % (', '.join(map(to_hex, data))), width=100, subsequent_indent='    '))
+    autocorrect_data_h_lines.append('};')
+
+    # Show the results
+    dump_lines(cli.args.output, autocorrect_data_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/community_modules.py b/lib/python/qmk/cli/generate/community_modules.py
new file mode 100644
index 0000000000..a5ab61f9bd
--- /dev/null
+++ b/lib/python/qmk/cli/generate/community_modules.py
@@ -0,0 +1,341 @@
+import contextlib
+from argcomplete.completers import FilesCompleter
+from pathlib import Path
+
+from milc import cli
+
+import qmk.path
+from qmk.info import get_modules
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.commands import dump_lines
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE
+from qmk.community_modules import module_api_list, load_module_jsons, find_module_path
+
+
+@contextlib.contextmanager
+def _render_api_guard(lines, api):
+    if api.guard:
+        lines.append(f'#if {api.guard}')
+    yield
+    if api.guard:
+        lines.append(f'#endif  // {api.guard}')
+
+
+def _render_api_header(api):
+    lines = []
+    if api.header:
+        lines.append('')
+        with _render_api_guard(lines, api):
+            lines.append(f'#include <{api.header}>')
+    return lines
+
+
+def _render_keycodes(module_jsons):
+    lines = []
+    lines.append('')
+    lines.append('enum {')
+    first = True
+    for module_json in module_jsons:
+        module_name = Path(module_json['module']).name
+        keycodes = module_json.get('keycodes', [])
+        if len(keycodes) > 0:
+            lines.append(f'    // From module: {module_name}')
+            for keycode in keycodes:
+                key = keycode.get('key', None)
+                if first:
+                    lines.append(f'    {key} = QK_COMMUNITY_MODULE,')
+                    first = False
+                else:
+                    lines.append(f'    {key},')
+                for alias in keycode.get('aliases', []):
+                    lines.append(f'    {alias} = {key},')
+            lines.append('')
+    lines.append('    LAST_COMMUNITY_MODULE_KEY')
+    lines.append('};')
+    lines.append('STATIC_ASSERT((int)LAST_COMMUNITY_MODULE_KEY <= (int)(QK_COMMUNITY_MODULE_MAX+1), "Too many community module keycodes");')
+    return lines
+
+
+def _render_api_declarations(api, module, user_kb=True):
+    lines = []
+    lines.append('')
+    with _render_api_guard(lines, api):
+        if user_kb:
+            lines.append(f'{api.ret_type} {api.name}_{module}_user({api.args});')
+            lines.append(f'{api.ret_type} {api.name}_{module}_kb({api.args});')
+        lines.append(f'{api.ret_type} {api.name}_{module}({api.args});')
+    return lines
+
+
+def _render_api_implementations(api, module):
+    module_name = Path(module).name
+    lines = []
+    lines.append('')
+    with _render_api_guard(lines, api):
+        # _user
+        lines.append(f'__attribute__((weak)) {api.ret_type} {api.name}_{module_name}_user({api.args}) {{')
+        if api.ret_type == 'bool':
+            lines.append('    return true;')
+        elif api.ret_type in ['layer_state_t', 'report_mouse_t']:
+            lines.append(f'    return {api.call_params};')
+        else:
+            pass
+        lines.append('}')
+        lines.append('')
+
+        # _kb
+        lines.append(f'__attribute__((weak)) {api.ret_type} {api.name}_{module_name}_kb({api.args}) {{')
+        if api.ret_type == 'bool':
+            lines.append(f'    if(!{api.name}_{module_name}_user({api.call_params})) {{ return false; }}')
+            lines.append('    return true;')
+        elif api.ret_type in ['layer_state_t', 'report_mouse_t']:
+            lines.append(f'    return {api.name}_{module_name}_user({api.call_params});')
+        else:
+            lines.append(f'    {api.name}_{module_name}_user({api.call_params});')
+        lines.append('}')
+        lines.append('')
+
+        # module (non-suffixed)
+        lines.append(f'__attribute__((weak)) {api.ret_type} {api.name}_{module_name}({api.args}) {{')
+        if api.ret_type == 'bool':
+            lines.append(f'    if(!{api.name}_{module_name}_kb({api.call_params})) {{ return false; }}')
+            lines.append('    return true;')
+        elif api.ret_type in ['layer_state_t', 'report_mouse_t']:
+            lines.append(f'    return {api.name}_{module_name}_kb({api.call_params});')
+        else:
+            lines.append(f'    {api.name}_{module_name}_kb({api.call_params});')
+        lines.append('}')
+    return lines
+
+
+def _render_core_implementation(api, modules):
+    lines = []
+    lines.append('')
+    with _render_api_guard(lines, api):
+        lines.append(f'{api.ret_type} {api.name}_modules({api.args}) {{')
+        if api.ret_type == 'bool':
+            lines.append('    return true')
+        for module in modules:
+            module_name = Path(module).name
+            if api.ret_type == 'bool':
+                lines.append(f'        && {api.name}_{module_name}({api.call_params})')
+            elif api.ret_type in ['layer_state_t', 'report_mouse_t']:
+                lines.append(f'    {api.call_params} = {api.name}_{module_name}({api.call_params});')
+            else:
+                lines.append(f'    {api.name}_{module_name}({api.call_params});')
+        if api.ret_type == 'bool':
+            lines.append('    ;')
+        elif api.ret_type in ['layer_state_t', 'report_mouse_t']:
+            lines.append(f'    return {api.call_params};')
+        lines.append('}')
+    return lines
+
+
+def _generate_features_rules(features_dict):
+    lines = []
+    for feature, enabled in features_dict.items():
+        feature = feature.upper()
+        enabled = 'yes' if enabled else 'no'
+        lines.append(f'{feature}_ENABLE={enabled}')
+    return lines
+
+
+def _generate_modules_rules(keyboard, filename):
+    lines = []
+    modules = get_modules(keyboard, filename)
+    if len(modules) > 0:
+        lines.append('')
+        lines.append('OPT_DEFS += -DCOMMUNITY_MODULES_ENABLE=TRUE')
+        for module in modules:
+            module_path = qmk.path.unix_style_path(find_module_path(module))
+            if not module_path:
+                raise FileNotFoundError(f"Module '{module}' not found.")
+            lines.append('')
+            lines.append(f'COMMUNITY_MODULES += {module_path.name}')  # use module_path here instead of module as it may be a subdirectory
+            lines.append(f'OPT_DEFS += -DCOMMUNITY_MODULE_{module_path.name.upper()}_ENABLE=TRUE')
+            lines.append(f'COMMUNITY_MODULE_PATHS += {module_path}')
+            lines.append(f'VPATH += {module_path}')
+            lines.append(f'SRC += $(wildcard {module_path}/{module_path.name}.c)')
+            lines.append(f'MODULE_NAME_{module_path.name.upper()} := {module_path.name}')
+            lines.append(f'MODULE_PATH_{module_path.name.upper()} := {module_path}')
+            lines.append(f'-include {module_path}/rules.mk')
+
+        module_jsons = load_module_jsons(modules)
+        for module_json in module_jsons:
+            if 'features' in module_json:
+                lines.append('')
+                lines.append(f'# Module: {module_json["module_name"]}')
+                lines.extend(_generate_features_rules(module_json['features']))
+    return lines
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-e', '--escape', arg_only=True, action='store_true', help="Escape spaces in quiet mode")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate rules.mk for.')
+@cli.argument('filename', nargs='?', arg_only=True, type=qmk.path.FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON to be compiled and flashed or a pre-compiled binary firmware file (bin/hex) to be flashed.')
+@cli.subcommand('Creates a community_modules_rules_mk from a keymap.json file.')
+def generate_community_modules_rules_mk(cli):
+
+    rules_mk_lines = [GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE]
+
+    rules_mk_lines.extend(_generate_modules_rules(cli.args.keyboard, cli.args.filename))
+
+    # Show the results
+    dump_lines(cli.args.output, rules_mk_lines)
+
+    if cli.args.output:
+        if cli.args.quiet:
+            if cli.args.escape:
+                print(cli.args.output.as_posix().replace(' ', '\\ '))
+            else:
+                print(cli.args.output)
+        else:
+            cli.log.info('Wrote rules.mk to %s.', cli.args.output)
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate community_modules.h for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a community_modules.h from a keymap.json file.')
+def generate_community_modules_h(cli):
+    """Creates a community_modules.h from a keymap.json file
+    """
+    if cli.args.output and cli.args.output.name == '-':
+        cli.args.output = None
+
+    api_list, api_version, ver_major, ver_minor, ver_patch = module_api_list()
+
+    lines = [
+        GPL2_HEADER_C_LIKE,
+        GENERATED_HEADER_C_LIKE,
+        '#pragma once',
+        '#include <stdint.h>',
+        '#include <stdbool.h>',
+        '#include <keycodes.h>',
+        '',
+        '#include "compiler_support.h"',
+        '',
+        '#define COMMUNITY_MODULES_API_VERSION_BUILDER(ver_major,ver_minor,ver_patch) (((((uint32_t)(ver_major))&0xFF) << 24) | ((((uint32_t)(ver_minor))&0xFF) << 16) | (((uint32_t)(ver_patch))&0xFF))',
+        f'#define COMMUNITY_MODULES_API_VERSION COMMUNITY_MODULES_API_VERSION_BUILDER({ver_major},{ver_minor},{ver_patch})',
+        f'#define ASSERT_COMMUNITY_MODULES_MIN_API_VERSION(ver_major,ver_minor,ver_patch) STATIC_ASSERT(COMMUNITY_MODULES_API_VERSION_BUILDER(ver_major,ver_minor,ver_patch) <= COMMUNITY_MODULES_API_VERSION, "Community module requires a newer version of QMK modules API -- needs: " #ver_major "." #ver_minor "." #ver_patch ", current: {api_version}.")',
+        '',
+        'typedef struct keyrecord_t keyrecord_t; // forward declaration so we don\'t need to include quantum.h',
+        '',
+    ]
+
+    modules = get_modules(cli.args.keyboard, cli.args.filename)
+    module_jsons = load_module_jsons(modules)
+    if len(modules) > 0:
+        lines.extend(_render_keycodes(module_jsons))
+
+        for api in api_list:
+            lines.extend(_render_api_header(api))
+
+        for module in modules:
+            lines.append('')
+            lines.append(f'// From module: {module}')
+            for api in api_list:
+                lines.extend(_render_api_declarations(api, Path(module).name))
+        lines.append('')
+
+        lines.append('// Core wrapper')
+        for api in api_list:
+            lines.extend(_render_api_declarations(api, 'modules', user_kb=False))
+
+    dump_lines(cli.args.output, lines, cli.args.quiet, remove_repeated_newlines=True)
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate community_modules.c for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a community_modules.c from a keymap.json file.')
+def generate_community_modules_c(cli):
+    """Creates a community_modules.c from a keymap.json file
+    """
+    if cli.args.output and cli.args.output.name == '-':
+        cli.args.output = None
+
+    api_list, _, _, _, _ = module_api_list()
+
+    lines = [
+        GPL2_HEADER_C_LIKE,
+        GENERATED_HEADER_C_LIKE,
+        '',
+        '#include "community_modules.h"',
+    ]
+
+    modules = get_modules(cli.args.keyboard, cli.args.filename)
+    if len(modules) > 0:
+
+        for module in modules:
+            for api in api_list:
+                lines.extend(_render_api_implementations(api, Path(module).name))
+
+        for api in api_list:
+            lines.extend(_render_core_implementation(api, modules))
+
+    dump_lines(cli.args.output, lines, cli.args.quiet, remove_repeated_newlines=True)
+
+
+def _generate_include_per_module(cli, include_file_name):
+    """Generates C code to include "<module_path>/include_file_name" for each module."""
+    if cli.args.output and cli.args.output.name == '-':
+        cli.args.output = None
+
+    lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE]
+
+    for module in get_modules(cli.args.keyboard, cli.args.filename):
+        full_path = f'{find_module_path(module)}/{include_file_name}'
+        lines.append('')
+        lines.append(f'#if __has_include("{full_path}")')
+        lines.append(f'#include "{full_path}"')
+        lines.append(f'#endif  // __has_include("{full_path}")')
+
+    dump_lines(cli.args.output, lines, cli.args.quiet, remove_repeated_newlines=True)
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate community_modules_introspection.h for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a community_modules_introspection.h from a keymap.json file.')
+def generate_community_modules_introspection_h(cli):
+    """Creates a community_modules_introspection.h from a keymap.json file
+    """
+    _generate_include_per_module(cli, 'introspection.h')
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate community_modules.c for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a community_modules_introspection.c from a keymap.json file.')
+def generate_community_modules_introspection_c(cli):
+    """Creates a community_modules_introspection.c from a keymap.json file
+    """
+    _generate_include_per_module(cli, 'introspection.c')
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate led_matrix_community_modules.inc for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates an led_matrix_community_modules.inc from a keymap.json file.')
+def generate_led_matrix_community_modules_inc(cli):
+    """Creates an led_matrix_community_modules.inc from a keymap.json file
+    """
+    _generate_include_per_module(cli, 'led_matrix_module.inc')
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate rgb_matrix_community_modules.inc for.')
+@cli.argument('filename', nargs='?', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates an rgb_matrix_community_modules.inc from a keymap.json file.')
+def generate_rgb_matrix_community_modules_inc(cli):
+    """Creates an rgb_matrix_community_modules.inc from a keymap.json file
+    """
+    _generate_include_per_module(cli, 'rgb_matrix_module.inc')
diff --git a/lib/python/qmk/cli/generate/compilation_database.py b/lib/python/qmk/cli/generate/compilation_database.py
new file mode 100644
index 0000000000..339b53c2c2
--- /dev/null
+++ b/lib/python/qmk/cli/generate/compilation_database.py
@@ -0,0 +1,9 @@
+from milc import cli
+
+
+@cli.argument('-kb', '--keyboard', help='[unused] The keyboard\'s name')
+@cli.argument('-km', '--keymap', help='[unused] The keymap\'s name')
+@cli.subcommand('[deprecated] Create a compilation database.')
+def generate_compilation_database(cli):
+    cli.log.error('This command is deprecated and has effectively been removed. Please use the `--compiledb` flag with `qmk compile` instead.')
+    return False
diff --git a/lib/python/qmk/cli/generate/config_h.py b/lib/python/qmk/cli/generate/config_h.py
new file mode 100755
index 0000000000..1ade452f95
--- /dev/null
+++ b/lib/python/qmk/cli/generate/config_h.py
@@ -0,0 +1,212 @@
+"""Used by the make system to generate info_config.h from info.json.
+"""
+from pathlib import Path
+from dotty_dict import dotty
+
+from argcomplete.completers import FilesCompleter
+from milc import cli
+
+from qmk.info import info_json
+from qmk.json_schema import json_load
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.commands import dump_lines, parse_configurator_json
+from qmk.path import normpath, FileType
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+
+
+def generate_define(define, value=None):
+    is_keymap = cli.args.filename
+    value = f' {value}' if value is not None else ''
+    if is_keymap:
+        return f"""
+#undef {define}
+#define {define}{value}"""
+    return f"""
+#ifndef {define}
+#    define {define}{value}
+#endif // {define}"""
+
+
+def direct_pins(direct_pins, postfix):
+    """Return the config.h lines that set the direct pins.
+    """
+    rows = []
+
+    for row in direct_pins:
+        cols = ','.join(map(str, [col or 'NO_PIN' for col in row]))
+        rows.append('{' + cols + '}')
+
+    return generate_define(f'DIRECT_PINS{postfix}', f'{{ {", ".join(rows)} }}')
+
+
+def pin_array(define, pins, postfix):
+    """Return the config.h lines that set a pin array.
+    """
+    pin_array = ', '.join(map(str, [pin or 'NO_PIN' for pin in pins]))
+
+    return generate_define(f'{define}_PINS{postfix}', f'{{ {pin_array} }}')
+
+
+def matrix_pins(matrix_pins, postfix=''):
+    """Add the matrix config to the config.h.
+    """
+    pins = []
+
+    if 'direct' in matrix_pins:
+        pins.append(direct_pins(matrix_pins['direct'], postfix))
+
+    if 'cols' in matrix_pins:
+        pins.append(pin_array('MATRIX_COL', matrix_pins['cols'], postfix))
+
+    if 'rows' in matrix_pins:
+        pins.append(pin_array('MATRIX_ROW', matrix_pins['rows'], postfix))
+
+    return '\n'.join(pins)
+
+
+def generate_matrix_size(kb_info_json, config_h_lines):
+    """Add the matrix size to the config.h.
+    """
+    if 'matrix_size' in kb_info_json:
+        config_h_lines.append(generate_define('MATRIX_COLS', kb_info_json['matrix_size']['cols']))
+        config_h_lines.append(generate_define('MATRIX_ROWS', kb_info_json['matrix_size']['rows']))
+
+
+def generate_config_items(kb_info_json, config_h_lines):
+    """Iterate through the info_config map to generate basic config values.
+    """
+    info_config_map = json_load(Path('data/mappings/info_config.hjson'))
+
+    for config_key, info_dict in info_config_map.items():
+        info_key = info_dict['info_key']
+        key_type = info_dict.get('value_type', 'raw')
+        to_c = info_dict.get('to_c', True)
+
+        if not to_c:
+            continue
+
+        try:
+            config_value = kb_info_json[info_key]
+        except KeyError:
+            continue
+
+        if key_type.startswith('array.array'):
+            config_h_lines.append(generate_define(config_key, f'{{ {", ".join(["{" + ",".join(list(map(str, x))) + "}" for x in config_value])} }}'))
+        elif key_type.startswith('array'):
+            config_h_lines.append(generate_define(config_key, f'{{ {", ".join(map(str, config_value))} }}'))
+        elif key_type == 'bool':
+            config_h_lines.append(generate_define(config_key, 'true' if config_value else 'false'))
+        elif key_type == 'flag':
+            if config_value:
+                config_h_lines.append(generate_define(config_key))
+        elif key_type == 'mapping':
+            for key, value in config_value.items():
+                config_h_lines.append(generate_define(key, value))
+        elif key_type == 'str':
+            escaped_str = config_value.replace('\\', '\\\\').replace('"', '\\"')
+            config_h_lines.append(generate_define(config_key, f'"{escaped_str}"'))
+        elif key_type == 'bcd_version':
+            (major, minor, revision) = config_value.split('.')
+            config_h_lines.append(generate_define(config_key, f'0x{major.zfill(2)}{minor}{revision}'))
+        else:
+            config_h_lines.append(generate_define(config_key, config_value))
+
+
+def generate_encoder_config(encoder_json, config_h_lines, postfix=''):
+    """Generate the config.h lines for encoders."""
+    a_pads = []
+    b_pads = []
+    resolutions = []
+    for encoder in encoder_json.get("rotary", []):
+        a_pads.append(encoder["pin_a"])
+        b_pads.append(encoder["pin_b"])
+        resolutions.append(encoder.get("resolution", None))
+
+    config_h_lines.append(generate_define(f'ENCODER_A_PINS{postfix}', f'{{ {", ".join(a_pads)} }}'))
+    config_h_lines.append(generate_define(f'ENCODER_B_PINS{postfix}', f'{{ {", ".join(b_pads)} }}'))
+
+    if len(resolutions) == 0 or all(r is None for r in resolutions):
+        cli.log.debug(f"Skipping ENCODER_RESOLUTION{postfix} configuration")
+        return
+
+    resolutions = [4 if r is None else r for r in resolutions]
+    if len(set(resolutions)) == 1:
+        config_h_lines.append(generate_define(f'ENCODER_RESOLUTION{postfix}', resolutions[0]))
+    else:
+        config_h_lines.append(generate_define(f'ENCODER_RESOLUTIONS{postfix}', f'{{ {", ".join(map(str,resolutions))} }}'))
+
+
+def generate_split_config(kb_info_json, config_h_lines):
+    """Generate the config.h lines for split boards."""
+    if 'handedness' in kb_info_json['split']:
+        # TODO: change SPLIT_HAND_MATRIX_GRID to require brackets
+        handedness = kb_info_json['split']['handedness']
+        if 'matrix_grid' in handedness:
+            config_h_lines.append(generate_define('SPLIT_HAND_MATRIX_GRID', ', '.join(handedness['matrix_grid'])))
+
+    if 'protocol' in kb_info_json['split'].get('transport', {}):
+        if kb_info_json['split']['transport']['protocol'] == 'i2c':
+            config_h_lines.append(generate_define('USE_I2C'))
+
+    if 'right' in kb_info_json['split'].get('matrix_pins', {}):
+        config_h_lines.append(matrix_pins(kb_info_json['split']['matrix_pins']['right'], '_RIGHT'))
+
+    if 'right' in kb_info_json['split'].get('encoder', {}):
+        generate_encoder_config(kb_info_json['split']['encoder']['right'], config_h_lines, '_RIGHT')
+
+
+def generate_led_animations_config(feature, led_feature_json, config_h_lines, enable_prefix, animation_prefix):
+    if 'animation' in led_feature_json.get('default', {}):
+        config_h_lines.append(generate_define(f'{feature.upper()}_DEFAULT_MODE', f'{animation_prefix}{led_feature_json["default"]["animation"].upper()}'))
+
+    for animation in led_feature_json.get('animations', {}):
+        if led_feature_json['animations'][animation]:
+            config_h_lines.append(generate_define(f'{enable_prefix}{animation.upper()}'))
+
+
+@cli.argument('filename', nargs='?', arg_only=True, type=FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON to be compiled and flashed or a pre-compiled binary firmware file (bin/hex) to be flashed.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate config.h for.')
+@cli.subcommand('Used by the make system to generate info_config.h from info.json', hidden=True)
+def generate_config_h(cli):
+    """Generates the info_config.h file.
+    """
+    # Determine our keyboard/keymap
+    if cli.args.filename:
+        user_keymap = parse_configurator_json(cli.args.filename)
+        kb_info_json = dotty(user_keymap.get('config', {}))
+    elif cli.args.keyboard:
+        kb_info_json = dotty(info_json(cli.args.keyboard))
+    else:
+        cli.log.error('You must supply a configurator export or `--keyboard`.')
+        cli.subcommands['generate-config-h'].print_help()
+        return False
+
+    # Build the info_config.h file.
+    config_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once']
+
+    generate_config_items(kb_info_json, config_h_lines)
+
+    generate_matrix_size(kb_info_json, config_h_lines)
+
+    if 'matrix_pins' in kb_info_json:
+        config_h_lines.append(matrix_pins(kb_info_json['matrix_pins']))
+
+    if 'encoder' in kb_info_json:
+        generate_encoder_config(kb_info_json['encoder'], config_h_lines)
+
+    if 'split' in kb_info_json:
+        generate_split_config(kb_info_json, config_h_lines)
+
+    if 'led_matrix' in kb_info_json:
+        generate_led_animations_config('led_matrix', kb_info_json['led_matrix'], config_h_lines, 'ENABLE_LED_MATRIX_', 'LED_MATRIX_')
+
+    if 'rgb_matrix' in kb_info_json:
+        generate_led_animations_config('rgb_matrix', kb_info_json['rgb_matrix'], config_h_lines, 'ENABLE_RGB_MATRIX_', 'RGB_MATRIX_')
+
+    if 'rgblight' in kb_info_json:
+        generate_led_animations_config('rgblight', kb_info_json['rgblight'], config_h_lines, 'RGBLIGHT_EFFECT_', 'RGBLIGHT_MODE_')
+
+    # Show the results
+    dump_lines(cli.args.output, config_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/develop_pr_list.py b/lib/python/qmk/cli/generate/develop_pr_list.py
new file mode 100755
index 0000000000..549db5b185
--- /dev/null
+++ b/lib/python/qmk/cli/generate/develop_pr_list.py
@@ -0,0 +1,130 @@
+"""Export the initial list of PRs associated with a `develop` merge to `master`.
+"""
+import os
+import re
+from pathlib import Path
+from subprocess import DEVNULL
+
+from milc import cli
+
+cache_timeout = 7 * 86400
+fix_expr = re.compile(r'fix', flags=re.IGNORECASE)
+clean1_expr = re.compile(r'\[(develop|keyboard|keymap|core|cli|bug|docs|feature)\]', flags=re.IGNORECASE)
+clean2_expr = re.compile(r'^(develop|keyboard|keymap|core|cli|bug|docs|feature):', flags=re.IGNORECASE)
+
+ignored_titles = ["Format code according to conventions"]
+
+
+def _is_ignored(title):
+    for ignore in ignored_titles:
+        if ignore in title:
+            return True
+    return False
+
+
+def _get_pr_info(cache, gh, pr_num):
+    pull = cache.get(f'pull:{pr_num}')
+    if pull is None:
+        print(f'Retrieving info for PR #{pr_num}')
+        pull = gh.pulls.get(owner='qmk', repo='qmk_firmware', pull_number=pr_num)
+        cache.set(f'pull:{pr_num}', pull, cache_timeout)
+    return pull
+
+
+def _try_open_cache(cli):
+    # These dependencies are manually handled because people complain. Fun.
+    try:
+        from sqlite_cache.sqlite_cache import SqliteCache
+    except ImportError:
+        return None
+
+    cache_loc = Path(cli.config_file).parent
+    return SqliteCache(cache_loc)
+
+
+def _get_github():
+    try:
+        from ghapi.all import GhApi
+    except ImportError:
+        return None
+
+    return GhApi()
+
+
+@cli.argument('-f', '--from-ref', default='0.11.0', help='Git revision/tag/reference/branch to begin search')
+@cli.argument('-b', '--branch', default='upstream/develop', help='Git branch to iterate (default: "upstream/develop")')
+@cli.subcommand('Creates the develop PR list.', hidden=False if cli.config.user.developer else True)
+def generate_develop_pr_list(cli):
+    """Retrieves information from GitHub regarding the list of PRs associated
+    with a merge of `develop` branch into `master`.
+
+    Requires environment variable GITHUB_TOKEN to be set.
+    """
+
+    if 'GITHUB_TOKEN' not in os.environ or os.environ['GITHUB_TOKEN'] == '':
+        cli.log.error('Environment variable "GITHUB_TOKEN" is not set.')
+        return 1
+
+    cache = _try_open_cache(cli)
+    gh = _get_github()
+
+    git_args = ['git', 'rev-list', '--oneline', '--no-merges', '--reverse', f'{cli.args.from_ref}...{cli.args.branch}', '^upstream/master']
+    commit_list = cli.run(git_args, capture_output=True, stdin=DEVNULL)
+
+    if cache is None or gh is None:
+        cli.log.error('Missing one or more dependent python packages: "ghapi", "python-sqlite-cache"')
+        return 1
+
+    pr_list_bugs = []
+    pr_list_dependencies = []
+    pr_list_core = []
+    pr_list_keyboards = []
+    pr_list_keyboard_fixes = []
+    pr_list_cli = []
+    pr_list_others = []
+
+    def _categorise_commit(commit_info):
+        def fix_or_normal(info, fixes_collection, normal_collection):
+            if "bug" in info['pr_labels'] or fix_expr.search(info['title']):
+                fixes_collection.append(info)
+            else:
+                normal_collection.append(info)
+
+        if _is_ignored(commit_info['title']):
+            return
+        elif "dependencies" in commit_info['pr_labels']:
+            fix_or_normal(commit_info, pr_list_bugs, pr_list_dependencies)
+        elif "core" in commit_info['pr_labels']:
+            fix_or_normal(commit_info, pr_list_bugs, pr_list_core)
+        elif "keyboard" in commit_info['pr_labels'] or "keymap" in commit_info['pr_labels'] or "via" in commit_info['pr_labels']:
+            fix_or_normal(commit_info, pr_list_keyboard_fixes, pr_list_keyboards)
+        elif "cli" in commit_info['pr_labels']:
+            fix_or_normal(commit_info, pr_list_bugs, pr_list_cli)
+        else:
+            fix_or_normal(commit_info, pr_list_bugs, pr_list_others)
+
+    git_expr = re.compile(r'^(?P<hash>[a-f0-9]+) (?P<title>.*) \(#(?P<pr>[0-9]+)\)$')
+    for line in commit_list.stdout.split('\n'):
+        match = git_expr.search(line)
+        if match:
+            pr_info = _get_pr_info(cache, gh, match.group("pr"))
+            commit_info = {'hash': match.group("hash"), 'title': pr_info['title'], 'pr_num': int(match.group("pr")), 'pr_labels': [label.name for label in pr_info.labels.items]}
+            _categorise_commit(commit_info)
+
+    def _dump_commit_list(name, collection):
+        if len(collection) == 0:
+            return
+        print("")
+        print(f"{name}:")
+        for commit in sorted(collection, key=lambda x: x['pr_num']):
+            title = clean1_expr.sub('', clean2_expr.sub('', commit['title'])).strip()
+            pr_num = commit['pr_num']
+            print(f'* {title} ([#{pr_num}](https://github.com/qmk/qmk_firmware/pull/{pr_num}))')
+
+    _dump_commit_list("Core", pr_list_core)
+    _dump_commit_list("CLI", pr_list_cli)
+    _dump_commit_list("Submodule updates", pr_list_dependencies)
+    _dump_commit_list("Keyboards", pr_list_keyboards)
+    _dump_commit_list("Keyboard fixes", pr_list_keyboard_fixes)
+    _dump_commit_list("Others", pr_list_others)
+    _dump_commit_list("Bugs", pr_list_bugs)
diff --git a/lib/python/qmk/cli/generate/dfu_header.py b/lib/python/qmk/cli/generate/dfu_header.py
new file mode 100644
index 0000000000..aa0252ca86
--- /dev/null
+++ b/lib/python/qmk/cli/generate/dfu_header.py
@@ -0,0 +1,50 @@
+"""Used by the make system to generate LUFA Keyboard.h from info.json
+"""
+from dotty_dict import dotty
+from milc import cli
+
+from qmk.decorators import automagic_keyboard
+from qmk.info import info_json
+from qmk.path import is_keyboard, normpath
+from qmk.keyboard import keyboard_completer
+from qmk.commands import dump_lines
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', completer=keyboard_completer, help='Keyboard to generate LUFA Keyboard.h for.')
+@cli.subcommand('Used by the make system to generate LUFA Keyboard.h from info.json', hidden=True)
+@automagic_keyboard
+def generate_dfu_header(cli):
+    """Generates the Keyboard.h file.
+    """
+    # Determine our keyboard(s)
+    if not cli.config.generate_dfu_header.keyboard:
+        cli.log.error('Missing parameter: --keyboard')
+        cli.subcommands['info'].print_help()
+        return False
+
+    if not is_keyboard(cli.config.generate_dfu_header.keyboard):
+        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_dfu_header.keyboard)
+        return False
+
+    # Build the Keyboard.h file.
+    kb_info_json = dotty(info_json(cli.config.generate_dfu_header.keyboard))
+
+    keyboard_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once']
+    keyboard_h_lines.append(f'#define MANUFACTURER "{kb_info_json["manufacturer"]}"')
+    keyboard_h_lines.append(f'#define PRODUCT "{kb_info_json["keyboard_name"]} Bootloader"')
+
+    # Optional
+    if 'qmk_lufa_bootloader.esc_output' in kb_info_json:
+        keyboard_h_lines.append(f'#define QMK_ESC_OUTPUT {kb_info_json["qmk_lufa_bootloader.esc_output"]}')
+    if 'qmk_lufa_bootloader.esc_input' in kb_info_json:
+        keyboard_h_lines.append(f'#define QMK_ESC_INPUT {kb_info_json["qmk_lufa_bootloader.esc_input"]}')
+    if 'qmk_lufa_bootloader.led' in kb_info_json:
+        keyboard_h_lines.append(f'#define QMK_LED {kb_info_json["qmk_lufa_bootloader.led"]}')
+    if 'qmk_lufa_bootloader.speaker' in kb_info_json:
+        keyboard_h_lines.append(f'#define QMK_SPEAKER {kb_info_json["qmk_lufa_bootloader.speaker"]}')
+
+    # Show the results
+    dump_lines(cli.args.output, keyboard_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/docs.py b/lib/python/qmk/cli/generate/docs.py
new file mode 100644
index 0000000000..7abeca9d2a
--- /dev/null
+++ b/lib/python/qmk/cli/generate/docs.py
@@ -0,0 +1,34 @@
+"""Build QMK documentation locally
+"""
+import shutil
+from qmk.docs import prepare_docs_build_area, run_docs_command, BUILD_DOCS_PATH
+
+from milc import cli
+
+
+@cli.argument('-s', '--serve', arg_only=True, action='store_true', help="Serves the generated docs once built.")
+@cli.subcommand('Build QMK documentation.', hidden=False if cli.config.user.developer else True)
+def generate_docs(cli):
+    """Invoke the docs generation process
+
+    TODO(unclaimed):
+        * [ ] Add a real build step... something static docs
+    """
+
+    if not shutil.which('doxygen'):
+        cli.log.error('doxygen is not installed. Please install it and try again.')
+        return
+
+    if not shutil.which('yarn'):
+        cli.log.error('yarn is not installed. Please install it and try again.')
+        return
+
+    if not prepare_docs_build_area(is_production=True):
+        return False
+
+    cli.log.info('Building vitepress docs')
+    run_docs_command('run', ['docs:build'])
+    cli.log.info('Successfully generated docs to %s.', BUILD_DOCS_PATH)
+
+    if cli.args.serve:
+        run_docs_command('run', ['docs:preview'])
diff --git a/lib/python/qmk/cli/generate/info_json.py b/lib/python/qmk/cli/generate/info_json.py
new file mode 100755
index 0000000000..08c294146b
--- /dev/null
+++ b/lib/python/qmk/cli/generate/info_json.py
@@ -0,0 +1,93 @@
+"""Keyboard information script.
+
+Compile an info.json for a particular keyboard and pretty-print it.
+"""
+import json
+
+from argcomplete.completers import FilesCompleter
+from jsonschema import Draft202012Validator, RefResolver, validators
+from milc import cli
+from pathlib import Path
+
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.info import info_json
+from qmk.json_encoders import InfoJSONEncoder
+from qmk.json_schema import compile_schema_store
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.path import is_keyboard, normpath
+
+
+def pruning_validator(validator_class):
+    """Extends Draft202012Validator to remove properties that aren't specified in the schema.
+    """
+    validate_properties = validator_class.VALIDATORS["properties"]
+
+    def remove_additional_properties(validator, properties, instance, schema):
+        for prop in list(instance.keys()):
+            if prop not in properties:
+                del instance[prop]
+
+        for error in validate_properties(validator, properties, instance, schema):
+            yield error
+
+    return validators.extend(validator_class, {"properties": remove_additional_properties})
+
+
+def strip_info_json(kb_info_json):
+    """Remove the API-only properties from the info.json.
+    """
+    schema_store = compile_schema_store()
+    pruning_draft_validator = pruning_validator(Draft202012Validator)
+    schema = schema_store['qmk.keyboard.v1']
+    resolver = RefResolver.from_schema(schema_store['qmk.keyboard.v1'], store=schema_store)
+    validator = pruning_draft_validator(schema, resolver=resolver).validate
+
+    return validator(kb_info_json)
+
+
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='Keyboard to show info for.')
+@cli.argument('-km', '--keymap', help='Show the layers for a JSON keymap too.')
+@cli.argument('-o', '--output', arg_only=True, completer=FilesCompleter, help='Write the output the specified file, overwriting if necessary.')
+@cli.argument('-ow', '--overwrite', arg_only=True, action='store_true', help='Overwrite the existing info.json. (Overrides the location of --output)')
+@cli.subcommand('Generate an info.json file for a keyboard.', hidden=False if cli.config.user.developer else True)
+@automagic_keyboard
+@automagic_keymap
+def generate_info_json(cli):
+    """Generate an info.json file for a keyboard
+    """
+    # Determine our keyboard(s)
+    if not cli.config.generate_info_json.keyboard:
+        cli.log.error('Missing parameter: --keyboard')
+        cli.subcommands['info'].print_help()
+        return False
+
+    if not is_keyboard(cli.config.generate_info_json.keyboard):
+        cli.log.error('Invalid keyboard: "%s"', cli.config.generate_info_json.keyboard)
+        return False
+
+    if cli.args.overwrite:
+        output_path = (Path('keyboards') / cli.config.generate_info_json.keyboard / 'info.json').resolve()
+
+        if cli.args.output:
+            cli.log.warning('Overwriting user supplied --output with %s', output_path)
+
+        cli.args.output = output_path
+
+    # Build the info.json file
+    kb_info_json = info_json(cli.config.generate_info_json.keyboard)
+    strip_info_json(kb_info_json)
+    info_json_text = json.dumps(kb_info_json, indent=4, cls=InfoJSONEncoder, sort_keys=True)
+
+    if cli.args.output:
+        # Write to a file
+        output_path = normpath(cli.args.output)
+
+        if output_path.exists():
+            cli.log.warning('Overwriting output file %s', output_path)
+
+        output_path.write_text(info_json_text + '\n')
+        cli.log.info('Wrote info.json to %s.', output_path)
+
+    else:
+        # Display the results
+        print(info_json_text)
diff --git a/lib/python/qmk/cli/generate/keyboard_c.py b/lib/python/qmk/cli/generate/keyboard_c.py
new file mode 100755
index 0000000000..1978de4a22
--- /dev/null
+++ b/lib/python/qmk/cli/generate/keyboard_c.py
@@ -0,0 +1,274 @@
+"""Used by the make system to generate keyboard.c from info.json.
+"""
+import bisect
+import dataclasses
+from typing import Optional
+
+from milc import cli
+
+from qmk.info import info_json
+from qmk.commands import dump_lines
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.path import normpath
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, JOYSTICK_AXES
+
+
+def _gen_led_configs(info_data):
+    lines = []
+
+    if 'layout' in info_data.get('rgb_matrix', {}):
+        lines.extend(_gen_led_config(info_data, 'rgb_matrix'))
+
+    if 'layout' in info_data.get('led_matrix', {}):
+        lines.extend(_gen_led_config(info_data, 'led_matrix'))
+
+    return lines
+
+
+def _gen_led_config(info_data, config_type):
+    """Convert info.json content to g_led_config
+    """
+    cols = info_data['matrix_size']['cols']
+    rows = info_data['matrix_size']['rows']
+
+    lines = []
+
+    matrix = [['NO_LED'] * cols for _ in range(rows)]
+    pos = []
+    flags = []
+
+    led_layout = info_data[config_type]['layout']
+    for index, led_data in enumerate(led_layout):
+        if 'matrix' in led_data:
+            row, col = led_data['matrix']
+            matrix[row][col] = str(index)
+        pos.append(f'{{{led_data.get("x", 0)}, {led_data.get("y", 0)}}}')
+        flags.append(str(led_data.get('flags', 0)))
+
+    if config_type == 'rgb_matrix':
+        lines.append('#ifdef RGB_MATRIX_ENABLE')
+        lines.append('#include "rgb_matrix.h"')
+    elif config_type == 'led_matrix':
+        lines.append('#ifdef LED_MATRIX_ENABLE')
+        lines.append('#include "led_matrix.h"')
+
+    lines.append('__attribute__ ((weak)) led_config_t g_led_config = {')
+    lines.append('  {')
+    for line in matrix:
+        lines.append(f'    {{ {", ".join(line)} }},')
+    lines.append('  },')
+    lines.append(f'  {{ {", ".join(pos)} }},')
+    lines.append(f'  {{ {", ".join(flags)} }},')
+    lines.append('};')
+    lines.append('#endif')
+    lines.append('')
+
+    return lines
+
+
+def _gen_matrix_mask(info_data):
+    """Convert info.json content to matrix_mask
+    """
+    cols = info_data['matrix_size']['cols']
+    rows = info_data['matrix_size']['rows']
+
+    # Default mask to everything disabled
+    mask = [['0'] * cols for _ in range(rows)]
+
+    # Mirror layout macros squashed on top of each other
+    for layout_name, layout_data in info_data['layouts'].items():
+        for key_data in layout_data['layout']:
+            row, col = key_data['matrix']
+            if row >= rows or col >= cols:
+                cli.log.error(f'Skipping matrix_mask due to {layout_name} containing invalid matrix values')
+                return []
+            mask[row][col] = '1'
+
+    lines = []
+    lines.append('#ifdef MATRIX_MASKED')
+    lines.append('__attribute__((weak)) const matrix_row_t matrix_mask[] = {')
+    for i in range(rows):
+        lines.append(f'    0b{"".join(reversed(mask[i]))},')
+    lines.append('};')
+    lines.append('#endif')
+    lines.append('')
+
+    return lines
+
+
+def _gen_joystick_axes(info_data):
+    """Convert info.json content to joystick_axes
+    """
+    if 'axes' not in info_data.get('joystick', {}):
+        return []
+
+    axes = info_data['joystick']['axes']
+    axes_keys = list(axes.keys())
+
+    lines = []
+    lines.append('#ifdef JOYSTICK_ENABLE')
+    lines.append('joystick_config_t joystick_axes[JOYSTICK_AXIS_COUNT] = {')
+
+    # loop over all available axes - injecting virtual axis for those not specified
+    for index, cur in enumerate(JOYSTICK_AXES):
+        # bail out if we have generated all requested axis
+        if len(axes_keys) == 0:
+            break
+
+        axis = 'virtual'
+        if cur in axes:
+            axis = axes[cur]
+            axes_keys.remove(cur)
+
+        if axis == 'virtual':
+            lines.append(f"    [{index}] = JOYSTICK_AXIS_VIRTUAL,")
+        else:
+            lines.append(f"    [{index}] = JOYSTICK_AXIS_IN({axis['input_pin']}, {axis['low']}, {axis['rest']}, {axis['high']}),")
+
+    lines.append('};')
+    lines.append('#endif')
+    lines.append('')
+
+    return lines
+
+
+@dataclasses.dataclass
+class LayoutKey:
+    """Geometric info for one key in a layout."""
+    row: int
+    col: int
+    x: float
+    y: float
+    w: float = 1.0
+    h: float = 1.0
+    hand: Optional[str] = None
+
+    @staticmethod
+    def from_json(key_json):
+        row, col = key_json['matrix']
+        return LayoutKey(
+            row=row,
+            col=col,
+            x=key_json['x'],
+            y=key_json['y'],
+            w=key_json.get('w', 1.0),
+            h=key_json.get('h', 1.0),
+            hand=key_json.get('hand', None),
+        )
+
+    @property
+    def cx(self):
+        """Center x coordinate of the key."""
+        return self.x + self.w / 2.0
+
+    @property
+    def cy(self):
+        """Center y coordinate of the key."""
+        return self.y + self.h / 2.0
+
+
+class Layout:
+    """Geometric info of a layout."""
+    def __init__(self, layout_json):
+        self.keys = [LayoutKey.from_json(key_json) for key_json in layout_json['layout']]
+        self.x_min = min(key.cx for key in self.keys)
+        self.x_max = max(key.cx for key in self.keys)
+        self.x_mid = (self.x_min + self.x_max) / 2
+        # If there is one key with width >= 6u, it is probably the spacebar.
+        i = [i for i, key in enumerate(self.keys) if key.w >= 6.0]
+        self.spacebar = self.keys[i[0]] if len(i) == 1 else None
+
+    def is_symmetric(self, tol: float = 0.02):
+        """Whether the key positions are symmetric about x_mid."""
+        x = sorted([key.cx for key in self.keys])
+        for i in range(len(x)):
+            x_i_mirrored = 2.0 * self.x_mid - x[i]
+            # Find leftmost x element greater than or equal to (x_i_mirrored - tol).
+            j = bisect.bisect_left(x, x_i_mirrored - tol)
+            if j == len(x) or abs(x[j] - x_i_mirrored) > tol:
+                return False
+
+        return True
+
+    def widest_horizontal_gap(self):
+        """Finds the x midpoint of the widest horizontal gap between keys."""
+        x = sorted([key.cx for key in self.keys])
+        x_mid = self.x_mid
+        max_sep = 0
+        for i in range(len(x) - 1):
+            sep = x[i + 1] - x[i]
+            if sep > max_sep:
+                max_sep = sep
+                x_mid = (x[i + 1] + x[i]) / 2
+
+        return x_mid
+
+
+def _gen_chordal_hold_layout(info_data):
+    """Convert info.json content to chordal_hold_layout
+    """
+    # NOTE: If there are multiple layouts, only the first is read.
+    for layout_name, layout_json in info_data['layouts'].items():
+        layout = Layout(layout_json)
+        break
+
+    if layout.is_symmetric():
+        # If the layout is symmetric (e.g. most split keyboards), guess the
+        # handedness based on the sign of (x - layout.x_mid).
+        hand_signs = [key.x - layout.x_mid for key in layout.keys]
+    elif layout.spacebar is not None:
+        # If the layout has a spacebar, form a dividing line through the spacebar,
+        # nearly vertical but with a slight angle to follow typical row stagger.
+        x0 = layout.spacebar.cx - 0.05
+        y0 = layout.spacebar.cy - 1.0
+        hand_signs = [(key.x - x0) - (key.y - y0) / 3.0 for key in layout.keys]
+    else:
+        # Fallback: assume handedness based on the widest horizontal separation.
+        x_mid = layout.widest_horizontal_gap()
+        hand_signs = [key.x - x_mid for key in layout.keys]
+
+    for key, hand_sign in zip(layout.keys, hand_signs):
+        if key.hand is None:
+            if key == layout.spacebar or abs(hand_sign) <= 0.02:
+                key.hand = '*'
+            else:
+                key.hand = 'L' if hand_sign < 0.0 else 'R'
+
+    lines = []
+    lines.append('#ifdef CHORDAL_HOLD')
+    line = ('__attribute__((weak)) const char chordal_hold_layout[MATRIX_ROWS][MATRIX_COLS] PROGMEM = ' + layout_name + '(')
+
+    x_prev = None
+    for key in layout.keys:
+        if x_prev is None or key.x < x_prev:
+            lines.append(line)
+            line = '  '
+        line += f"'{key.hand}', "
+        x_prev = key.x
+
+    lines.append(line[:-2])
+    lines.append(');')
+    lines.append('#endif')
+
+    return lines
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, required=True, help='Keyboard to generate keyboard.c for.')
+@cli.subcommand('Used by the make system to generate keyboard.c from info.json', hidden=True)
+def generate_keyboard_c(cli):
+    """Generates the keyboard.h file.
+    """
+    kb_info_json = info_json(cli.args.keyboard)
+
+    # Build the layouts.h file.
+    keyboard_c_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#include QMK_KEYBOARD_H', '']
+
+    keyboard_c_lines.extend(_gen_led_configs(kb_info_json))
+    keyboard_c_lines.extend(_gen_matrix_mask(kb_info_json))
+    keyboard_c_lines.extend(_gen_joystick_axes(kb_info_json))
+    keyboard_c_lines.extend(_gen_chordal_hold_layout(kb_info_json))
+
+    # Show the results
+    dump_lines(cli.args.output, keyboard_c_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/keyboard_h.py b/lib/python/qmk/cli/generate/keyboard_h.py
new file mode 100755
index 0000000000..cb9528d96b
--- /dev/null
+++ b/lib/python/qmk/cli/generate/keyboard_h.py
@@ -0,0 +1,130 @@
+"""Used by the make system to generate keyboard.h from info.json.
+"""
+from pathlib import Path
+
+from milc import cli
+
+from qmk.path import normpath
+from qmk.info import info_json
+from qmk.commands import dump_lines
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.constants import COL_LETTERS, ROW_LETTERS, GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+
+
+def _generate_layouts(keyboard, kb_info_json):
+    """Generates the layouts macros.
+    """
+    if 'matrix_size' not in kb_info_json:
+        cli.log.error(f'{keyboard}: Invalid matrix config.')
+        return []
+
+    col_num = kb_info_json['matrix_size']['cols']
+    row_num = kb_info_json['matrix_size']['rows']
+
+    lines = []
+    lines.append('')
+    lines.append('// Layout content')
+    lines.append('')
+    lines.append('#define XXX KC_NO')
+
+    for layout_name, layout_data in kb_info_json['layouts'].items():
+        if layout_data['c_macro']:
+            continue
+
+        if not all('matrix' in key_data for key_data in layout_data['layout']):
+            cli.log.debug(f'{keyboard}/{layout_name}: No or incomplete matrix data!')
+            continue
+
+        layout_keys = []
+        layout_matrix = [['XXX'] * col_num for _ in range(row_num)]
+
+        for key_data in layout_data['layout']:
+            row, col = key_data['matrix']
+            identifier = f'k{ROW_LETTERS[row]}{COL_LETTERS[col]}'
+            if row >= row_num or col >= col_num:
+                cli.log.error(f'Skipping layouts due to {layout_name} containing invalid matrix values')
+                return []
+
+            layout_matrix[row][col] = identifier
+            layout_keys.append(identifier)
+
+        lines.append('')
+        lines.append(f'#define {layout_name}({", ".join(layout_keys)}) {{ \\')
+
+        rows = ', \\\n'.join(['    { ' + ', '.join(row) + ' }' for row in layout_matrix])
+        rows += ' \\'
+        lines.append(rows)
+        lines.append('}')
+
+    for alias, target in kb_info_json.get('layout_aliases', {}).items():
+        lines.append('')
+        lines.append(f'#ifndef {alias}')
+        lines.append(f'#   define {alias} {target}')
+        lines.append('#endif')
+
+    return lines
+
+
+def _generate_keycodes(kb_info_json):
+    """Generates keyboard level keycodes.
+    """
+    if 'keycodes' not in kb_info_json:
+        return []
+
+    lines = []
+    lines.append('')
+    lines.append('// Keycode content')
+    lines.append('')
+    lines.append('enum keyboard_keycodes {')
+
+    for index, item in enumerate(kb_info_json.get('keycodes')):
+        key = item["key"]
+        if index == 0:
+            lines.append(f'  {key} = QK_KB_0,')
+        else:
+            lines.append(f'  {key},')
+
+    lines.append('};')
+
+    for item in kb_info_json.get('keycodes', []):
+        key = item["key"]
+        for alias in item.get("aliases", []):
+            lines.append(f'#define {alias} {key}')
+
+    return lines
+
+
+@cli.argument('-i', '--include', nargs='?', arg_only=True, help='Optional file to include')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, required=True, help='Keyboard to generate keyboard.h for.')
+@cli.subcommand('Used by the make system to generate keyboard.h from info.json', hidden=True)
+def generate_keyboard_h(cli):
+    """Generates the keyboard.h file.
+    """
+    # Build the info.json file
+    kb_info_json = info_json(cli.args.keyboard)
+
+    keyboard_h = cli.args.include
+    dd_layouts = _generate_layouts(cli.args.keyboard, kb_info_json)
+    dd_keycodes = _generate_keycodes(kb_info_json)
+    valid_config = dd_layouts or keyboard_h
+
+    # Build the layouts.h file.
+    keyboard_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '', '#include "quantum.h"']
+
+    if dd_layouts:
+        keyboard_h_lines.extend(dd_layouts)
+
+    if keyboard_h:
+        keyboard_h_lines.append(f'#include "{Path(keyboard_h).name}"')
+
+    if dd_keycodes:
+        keyboard_h_lines.extend(dd_keycodes)
+
+    # Protect against poorly configured keyboards
+    if not valid_config:
+        keyboard_h_lines.append('#error("<keyboard>.h is required unless your keyboard uses data-driven configuration. Please rename your keyboard\'s header file to <keyboard>.h")')
+
+    # Show the results
+    dump_lines(cli.args.output, keyboard_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/keycodes.py b/lib/python/qmk/cli/generate/keycodes.py
new file mode 100644
index 0000000000..d694202aec
--- /dev/null
+++ b/lib/python/qmk/cli/generate/keycodes.py
@@ -0,0 +1,182 @@
+"""Used by the make system to generate keycodes.h from keycodes_{version}.json
+"""
+from milc import cli
+
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+from qmk.commands import dump_lines
+from qmk.path import normpath
+from qmk.keycodes import load_spec
+
+
+def _translate_group(group):
+    """Fix up any issues with badly chosen values
+    """
+    if group == 'modifiers':
+        return 'modifier'
+    if group == 'media':
+        return 'consumer'
+    return group
+
+
+def _render_key(key):
+    width = 7
+    if 'S(' in key:
+        width += len('S()')
+    if 'A(' in key:
+        width += len('A()')
+    if 'RCTL(' in key:
+        width += len('RCTL()')
+    if 'ALGR(' in key:
+        width += len('ALGR()')
+    return key.ljust(width)
+
+
+def _render_label(label):
+    label = label.replace("\\", "(backslash)")
+    return label
+
+
+def _generate_ranges(lines, keycodes):
+    lines.append('')
+    lines.append('enum qk_keycode_ranges {')
+    lines.append('// Ranges')
+    for key, value in keycodes["ranges"].items():
+        lo, mask = map(lambda x: int(x, 16), key.split("/"))
+        hi = lo + mask
+        define = value.get("define")
+        lines.append(f'    {define.ljust(30)} = 0x{lo:04X},')
+        lines.append(f'    {(define + "_MAX").ljust(30)} = 0x{hi:04X},')
+    lines.append('};')
+
+
+def _generate_defines(lines, keycodes):
+    lines.append('')
+    lines.append('enum qk_keycode_defines {')
+    lines.append('// Keycodes')
+    for key, value in keycodes["keycodes"].items():
+        lines.append(f'    {value.get("key")} = {key},')
+
+    lines.append('')
+    lines.append('// Alias')
+    for key, value in keycodes["keycodes"].items():
+        temp = value.get("key")
+        for alias in value.get("aliases", []):
+            lines.append(f'    {alias.ljust(10)} = {temp},')
+
+    lines.append('};')
+
+
+def _generate_helpers(lines, keycodes):
+    lines.append('')
+    lines.append('// Range Helpers')
+    for value in keycodes["ranges"].values():
+        define = value.get("define")
+        lines.append(f'#define IS_{define}(code) ((code) >= {define} && (code) <= {define + "_MAX"})')
+
+    # extract min/max
+    temp = {}
+    for key, value in keycodes["keycodes"].items():
+        group = value.get('group', None)
+        if not group:
+            continue
+        if group not in temp:
+            temp[group] = [0xFFFF, 0]
+        key = int(key, 16)
+        if key < temp[group][0]:
+            temp[group][0] = key
+        if key > temp[group][1]:
+            temp[group][1] = key
+
+    lines.append('')
+    lines.append('// Group Helpers')
+    for group, codes in temp.items():
+        lo = keycodes["keycodes"][f'0x{codes[0]:04X}']['key']
+        hi = keycodes["keycodes"][f'0x{codes[1]:04X}']['key']
+        lines.append(f'#define IS_{_translate_group(group).upper()}_KEYCODE(code) ((code) >= {lo} && (code) <= {hi})')
+
+    lines.append('')
+    lines.append('// Switch statement Helpers')
+    for group, codes in temp.items():
+        lo = keycodes["keycodes"][f'0x{codes[0]:04X}']['key']
+        hi = keycodes["keycodes"][f'0x{codes[1]:04X}']['key']
+        name = f'{_translate_group(group).upper()}_KEYCODE_RANGE'
+        lines.append(f'#define {name.ljust(35)} {lo} ... {hi}')
+
+
+def _generate_aliases(lines, keycodes):
+    # Work around ChibiOS ch.h include guard
+    if 'CH_H' in [value['key'] for value in keycodes['aliases'].values()]:
+        lines.append('')
+        lines.append('#undef CH_H')
+
+    lines.append('')
+    lines.append('// Aliases')
+    for key, value in keycodes["aliases"].items():
+        define = _render_key(value.get("key"))
+        val = _render_key(key)
+        if 'label' in value:
+            lines.append(f'#define {define} {val} // {_render_label(value.get("label"))}')
+        else:
+            lines.append(f'#define {define} {val}')
+
+    lines.append('')
+    for key, value in keycodes["aliases"].items():
+        for alias in value.get("aliases", []):
+            lines.append(f'#define {alias} {value.get("key")}')
+
+
+def _generate_version(lines, keycodes, prefix=''):
+    version = keycodes['version']
+    major, minor, patch = map(int, version.split('.'))
+
+    bcd = f'0x{major:02d}{minor:02d}{patch:04d}'
+
+    lines.append('')
+    lines.append(f'#define QMK_{prefix}KEYCODES_VERSION "{version}"')
+    lines.append(f'#define QMK_{prefix}KEYCODES_VERSION_BCD {bcd}')
+    lines.append(f'#define QMK_{prefix}KEYCODES_VERSION_MAJOR {major}')
+    lines.append(f'#define QMK_{prefix}KEYCODES_VERSION_MINOR {minor}')
+    lines.append(f'#define QMK_{prefix}KEYCODES_VERSION_PATCH {patch}')
+
+
+@cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.subcommand('Used by the make system to generate keycodes.h from keycodes_{version}.json', hidden=True)
+def generate_keycodes(cli):
+    """Generates the keycodes.h file.
+    """
+
+    # Build the keycodes.h file.
+    keycodes_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '// clang-format off']
+
+    keycodes = load_spec(cli.args.version)
+
+    _generate_version(keycodes_h_lines, keycodes)
+    _generate_ranges(keycodes_h_lines, keycodes)
+    _generate_defines(keycodes_h_lines, keycodes)
+    _generate_helpers(keycodes_h_lines, keycodes)
+
+    # Show the results
+    dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet)
+
+
+@cli.argument('-v', '--version', arg_only=True, required=True, help='Version of keycodes to generate.')
+@cli.argument('-l', '--lang', arg_only=True, required=True, help='Language of keycodes to generate.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.subcommand('Used by the make system to generate keymap_{lang}.h from keycodes_{lang}_{version}.json', hidden=True)
+def generate_keycode_extras(cli):
+    """Generates the header file.
+    """
+
+    # Build the header file.
+    keycodes_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '#include "keycodes.h"', '// clang-format off']
+
+    keycodes = load_spec(cli.args.version, cli.args.lang)
+
+    _generate_version(keycodes_h_lines, keycodes, f'{cli.args.lang.upper()}_')
+    _generate_aliases(keycodes_h_lines, keycodes)
+
+    # Show the results
+    dump_lines(cli.args.output, keycodes_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/keymap_h.py b/lib/python/qmk/cli/generate/keymap_h.py
new file mode 100644
index 0000000000..a3aaa405c0
--- /dev/null
+++ b/lib/python/qmk/cli/generate/keymap_h.py
@@ -0,0 +1,51 @@
+from argcomplete.completers import FilesCompleter
+
+from milc import cli
+
+import qmk.path
+from qmk.commands import dump_lines
+from qmk.commands import parse_configurator_json
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+
+
+def _generate_keycodes_function(keymap_json):
+    """Generates keymap level keycodes.
+    """
+    lines = []
+    lines.append('enum keymap_keycodes {')
+
+    for index, item in enumerate(keymap_json.get('keycodes', [])):
+        key = item["key"]
+        if index == 0:
+            lines.append(f'  {key} = QK_USER_0,')
+        else:
+            lines.append(f'  {key},')
+
+    lines.append('};')
+
+    for item in keymap_json.get('keycodes', []):
+        key = item["key"]
+        for alias in item.get("aliases", []):
+            lines.append(f'#define {alias} {key}')
+
+    return lines
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('filename', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a keymap.h from a QMK Configurator export.')
+def generate_keymap_h(cli):
+    """Creates a keymap.h from a QMK Configurator export
+    """
+    if cli.args.output and cli.args.output.name == '-':
+        cli.args.output = None
+
+    keymap_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '// clang-format off']
+
+    keymap_json = parse_configurator_json(cli.args.filename)
+
+    if 'keycodes' in keymap_json and keymap_json['keycodes'] is not None:
+        keymap_h_lines += _generate_keycodes_function(keymap_json)
+
+    dump_lines(cli.args.output, keymap_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/make_dependencies.py b/lib/python/qmk/cli/generate/make_dependencies.py
new file mode 100755
index 0000000000..9548187888
--- /dev/null
+++ b/lib/python/qmk/cli/generate/make_dependencies.py
@@ -0,0 +1,56 @@
+"""Used by the make system to generate dependency lists for each of the generated files.
+"""
+from pathlib import Path
+from milc import cli
+
+from argcomplete.completers import FilesCompleter
+
+from qmk.commands import dump_lines
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.keymap import keymap_completer, locate_keymap
+from qmk.path import normpath, FileType, unix_style_path
+
+
+@cli.argument('filename', nargs='?', arg_only=True, type=FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, required=True, help='Keyboard to generate dependency file for.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.subcommand('Generates the list of dependencies associated with a keyboard build and its generated files.', hidden=True)
+def generate_make_dependencies(cli):
+    """Generates the list of dependent config files for a keyboard.
+    """
+    interesting_files = [
+        'info.json',
+        'keyboard.json',
+        'rules.mk',
+        'post_rules.mk',
+        'config.h',
+        'post_config.h',
+    ]
+
+    check_files = []
+
+    # Walk up the keyboard's directory tree looking for the files we're interested in
+    keyboards_root = Path('keyboards')
+    parent_path = Path('keyboards') / cli.args.keyboard
+    while parent_path != keyboards_root:
+        for file in interesting_files:
+            check_files.append(parent_path / file)
+        parent_path = parent_path.parent
+
+    # Find the keymap and include any of the interesting files
+    if cli.args.keymap is not None:
+        km = locate_keymap(cli.args.keyboard, cli.args.keymap)
+        if km is not None:
+            # keymap.json is only valid for the keymap, so check this one separately
+            check_files.append(km.parent / 'keymap.json')
+            # Add all the interesting files
+            for file in interesting_files:
+                check_files.append(km.parent / file)
+
+    # If we have a matching userspace, include those too
+    for file in interesting_files:
+        check_files.append(Path('users') / cli.args.keymap / file)
+
+    dump_lines(cli.args.output, [f'generated-files: $(wildcard {unix_style_path(found)})\n' for found in check_files])
diff --git a/lib/python/qmk/cli/generate/rgb_breathe_table.py b/lib/python/qmk/cli/generate/rgb_breathe_table.py
new file mode 100644
index 0000000000..55c80f6015
--- /dev/null
+++ b/lib/python/qmk/cli/generate/rgb_breathe_table.py
@@ -0,0 +1,78 @@
+"""Generate rgblight_breathe_table.h
+"""
+import math
+from argparse import ArgumentTypeError
+
+from milc import cli
+
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+from qmk.commands import dump_lines
+from qmk.path import normpath
+
+
+def breathing_center(value):
+    value = float(value)
+    if value >= 1 and value <= 2.7:
+        return value
+    else:
+        raise ArgumentTypeError('Breathing center must be between 1 and 2.7')
+
+
+def breathing_max(value):
+    value = int(value)
+    if value in range(0, 256):
+        return value
+    else:
+        raise ArgumentTypeError('Breathing max must be between 0 and 255')
+
+
+def _generate_table(lines, center, maximum):
+    breathe_values = [0] * 256
+    for pos in range(0, 256):
+        breathe_values[pos] = (int)((math.exp(math.sin((pos / 255) * math.pi)) - center / math.e) * (maximum / (math.e - 1 / math.e)))
+
+    values_template = ''
+    for s in range(0, 3):
+        step = 1 << s
+
+        values_template += '#if RGBLIGHT_BREATHE_TABLE_SIZE == {}\n'.format(256 >> s)
+
+        for pos in range(0, 256, step):
+            values_template += '    ' if pos % 8 == 0 else ''
+            values_template += '0x{:02X}'.format(breathe_values[pos])
+            values_template += ',' if (pos + step) < 256 else ''
+            values_template += '\n' if (pos + step) % 8 == 0 else ' '
+
+        values_template += '#endif'
+        values_template += '\n\n' if s < 2 else ''
+
+    table_template = '''#define RGBLIGHT_EFFECT_BREATHE_TABLE
+
+// Breathing center: {0:.2f}
+// Breathing max:    {1:d}
+
+const uint8_t PROGMEM rgblight_effect_breathe_table[] = {{
+{2}
+}};
+
+static const int table_scale = 256 / sizeof(rgblight_effect_breathe_table);
+'''.format(center, maximum, values_template)
+    lines.append(table_template)
+
+
+@cli.argument('-c', '--center', arg_only=True, type=breathing_center, default=1.85, help='The breathing center value, from 1 to 2.7. Default: 1.85')
+@cli.argument('-m', '--max', arg_only=True, type=breathing_max, default=255, help='The breathing maximum value, from 0 to 255. Default: 255')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help='Quiet mode, only output error messages')
+@cli.subcommand('Generates an RGB Light breathing table header.')
+def generate_rgb_breathe_table(cli):
+    """Generate a rgblight_breathe_table.h file containing a breathing LUT for RGB Lighting (Underglow) feature.
+    """
+
+    # Build the header file.
+    header_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once', '// clang-format off']
+
+    _generate_table(header_lines, cli.args.center, cli.args.max)
+
+    # Show the results
+    dump_lines(cli.args.output, header_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/generate/rules_mk.py b/lib/python/qmk/cli/generate/rules_mk.py
new file mode 100755
index 0000000000..16084bded1
--- /dev/null
+++ b/lib/python/qmk/cli/generate/rules_mk.py
@@ -0,0 +1,117 @@
+"""Used by the make system to generate a rules.mk
+"""
+from pathlib import Path
+from dotty_dict import dotty
+
+from argcomplete.completers import FilesCompleter
+from milc import cli
+
+from qmk.info import info_json
+from qmk.json_schema import json_load
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.commands import dump_lines, parse_configurator_json
+from qmk.path import normpath, FileType
+from qmk.constants import GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE
+
+
+def generate_rule(rules_key, rules_value):
+    is_keymap = cli.args.filename
+    rule_assignment_operator = '=' if is_keymap else '?='
+    return f'{rules_key} {rule_assignment_operator} {rules_value}'
+
+
+def process_mapping_rule(kb_info_json, rules_key, info_dict):
+    """Return the rules.mk line(s) for a mapping rule.
+    """
+    if not info_dict.get('to_c', True):
+        return None
+
+    info_key = info_dict['info_key']
+    key_type = info_dict.get('value_type', 'raw')
+
+    try:
+        rules_value = kb_info_json[info_key]
+    except KeyError:
+        return None
+
+    if key_type in ['array', 'list']:
+        return generate_rule(rules_key, " ".join(rules_value))
+    elif key_type == 'bool':
+        return generate_rule(rules_key, "yes" if rules_value else "no")
+    elif key_type == 'mapping':
+        return '\n'.join([generate_rule(key, value) for key, value in rules_value.items()])
+    elif key_type == 'str':
+        return generate_rule(rules_key, f'"{rules_value}"')
+
+    return generate_rule(rules_key, rules_value)
+
+
+def generate_features_rules(features_dict):
+    lines = []
+    for feature, enabled in features_dict.items():
+        feature = feature.upper()
+        enabled = 'yes' if enabled else 'no'
+        lines.append(generate_rule(f'{feature}_ENABLE', enabled))
+    return lines
+
+
+@cli.argument('filename', nargs='?', arg_only=True, type=FileType('r'), completer=FilesCompleter('.json'), help='A configurator export JSON to be compiled and flashed or a pre-compiled binary firmware file (bin/hex) to be flashed.')
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('-e', '--escape', arg_only=True, action='store_true', help="Escape spaces in quiet mode")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, help='Keyboard to generate rules.mk for.')
+@cli.subcommand('Used by the make system to generate rules.mk from info.json', hidden=True)
+def generate_rules_mk(cli):
+    """Generates a rules.mk file from info.json.
+    """
+    converter = None
+    # Determine our keyboard/keymap
+    if cli.args.filename:
+        user_keymap = parse_configurator_json(cli.args.filename)
+        kb_info_json = dotty(user_keymap.get('config', {}))
+        converter = user_keymap.get('converter', None)
+    elif cli.args.keyboard:
+        kb_info_json = dotty(info_json(cli.args.keyboard))
+    else:
+        cli.log.error('You must supply a configurator export or `--keyboard`.')
+        cli.subcommands['generate-rules-mk'].print_help()
+        return False
+
+    info_rules_map = json_load(Path('data/mappings/info_rules.hjson'))
+    rules_mk_lines = [GPL2_HEADER_SH_LIKE, GENERATED_HEADER_SH_LIKE]
+
+    # Iterate through the info_rules map to generate basic rules
+    for rules_key, info_dict in info_rules_map.items():
+        new_entry = process_mapping_rule(kb_info_json, rules_key, info_dict)
+
+        if new_entry:
+            rules_mk_lines.append(new_entry)
+
+    # Iterate through features to enable/disable them
+    if 'features' in kb_info_json:
+        rules_mk_lines.extend(generate_features_rules(kb_info_json['features']))
+
+    # Set SPLIT_TRANSPORT, if needed
+    if kb_info_json.get('split', {}).get('transport', {}).get('protocol') == 'custom':
+        rules_mk_lines.append(generate_rule('SPLIT_TRANSPORT', 'custom'))
+
+    # Set CUSTOM_MATRIX, if needed
+    if kb_info_json.get('matrix_pins', {}).get('custom_lite'):
+        rules_mk_lines.append(generate_rule('CUSTOM_MATRIX', 'lite'))
+    elif kb_info_json.get('matrix_pins', {}).get('custom'):
+        rules_mk_lines.append(generate_rule('CUSTOM_MATRIX', 'yes'))
+
+    if converter:
+        rules_mk_lines.append(generate_rule('CONVERT_TO', converter))
+
+    # Show the results
+    dump_lines(cli.args.output, rules_mk_lines)
+
+    if cli.args.output:
+        if cli.args.quiet:
+            if cli.args.escape:
+                print(cli.args.output.as_posix().replace(' ', '\\ '))
+            else:
+                print(cli.args.output)
+        else:
+            cli.log.info('Wrote rules.mk to %s.', cli.args.output)
diff --git a/lib/python/qmk/cli/generate/version_h.py b/lib/python/qmk/cli/generate/version_h.py
new file mode 100644
index 0000000000..8156e85559
--- /dev/null
+++ b/lib/python/qmk/cli/generate/version_h.py
@@ -0,0 +1,62 @@
+"""Used by the make system to generate version.h for use in code.
+"""
+from time import strftime
+
+from milc import cli
+
+from qmk.path import normpath
+from qmk.commands import dump_lines
+from qmk.git import git_get_qmk_hash, git_get_version, git_is_dirty
+from qmk.constants import GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE
+from qmk.util import triplet_to_bcd
+
+TIME_FMT = '%Y-%m-%d-%H:%M:%S'
+
+
+@cli.argument('-o', '--output', arg_only=True, type=normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('--skip-git', arg_only=True, action='store_true', help='Skip Git operations')
+@cli.argument('--skip-all', arg_only=True, action='store_true', help='Use placeholder values for all defines (implies --skip-git)')
+@cli.subcommand('Used by the make system to generate version.h for use in code', hidden=True)
+def generate_version_h(cli):
+    """Generates the version.h file.
+    """
+    if cli.args.skip_all:
+        cli.args.skip_git = True
+
+    if cli.args.skip_all:
+        current_time = "1970-01-01-00:00:00"
+    else:
+        current_time = strftime(TIME_FMT)
+
+    if cli.args.skip_git:
+        git_dirty = False
+        git_version = "NA"
+        git_qmk_hash = "NA"
+        git_bcd_version = "0x00000000"
+        chibios_version = "NA"
+        chibios_contrib_version = "NA"
+    else:
+        git_dirty = git_is_dirty()
+        git_version = git_get_version() or current_time
+        git_qmk_hash = git_get_qmk_hash() or "Unknown"
+        git_bcd_version = triplet_to_bcd(git_version)
+        chibios_version = git_get_version("chibios", "os") or current_time
+        chibios_contrib_version = git_get_version("chibios-contrib", "os") or current_time
+
+    # Build the version.h file.
+    version_h_lines = [GPL2_HEADER_C_LIKE, GENERATED_HEADER_C_LIKE, '#pragma once']
+
+    version_h_lines.append(
+        f"""
+#define QMK_VERSION "{git_version}"
+#define QMK_BUILDDATE "{current_time}"
+#define QMK_VERSION_BCD {git_bcd_version}
+#define QMK_GIT_HASH  "{git_qmk_hash}{'*' if git_dirty else ''}"
+#define CHIBIOS_VERSION "{chibios_version}"
+#define CHIBIOS_CONTRIB_VERSION "{chibios_contrib_version}"
+"""
+    )
+
+    # Show the results
+    dump_lines(cli.args.output, version_h_lines, cli.args.quiet)
diff --git a/lib/python/qmk/cli/git/__init__.py b/lib/python/qmk/cli/git/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/git/__init__.py
diff --git a/lib/python/qmk/cli/git/submodule.py b/lib/python/qmk/cli/git/submodule.py
new file mode 100644
index 0000000000..1cbfd74e88
--- /dev/null
+++ b/lib/python/qmk/cli/git/submodule.py
@@ -0,0 +1,53 @@
+import shutil
+from pathlib import Path
+
+from milc import cli
+
+from qmk import submodules
+
+REMOVE_DIRS = [
+    'lib/ugfx',
+    'lib/chibios-contrib/ext/mcux-sdk',
+]
+
+IGNORE_DIRS = [
+    'lib/arm_atsam',
+    'lib/fnv',
+    'lib/lib8tion',
+    'lib/python',
+    'lib/usbhost',
+]
+
+
+@cli.argument('--check', arg_only=True, action='store_true', help='Check if the submodules are dirty, and display a warning if they are.')
+@cli.argument('--sync', arg_only=True, action='store_true', help='Shallow clone any missing submodules.')
+@cli.argument('-f', '--force', action='store_true', help='Flag to remove unexpected directories')
+@cli.subcommand('Git Submodule actions.')
+def git_submodule(cli):
+    """Git Submodule actions
+    """
+    if cli.args.check:
+        return all(item['status'] for item in submodules.status().values())
+
+    if cli.args.sync:
+        cli.run(['git', 'submodule', 'sync', '--recursive'])
+        for name, item in submodules.status().items():
+            if item['status'] is None:
+                cli.run(['git', 'submodule', 'update', '--depth=50', '--init', name], capture_output=False)
+        return True
+
+    # can be the default behavior with: qmk config git_submodule.force=True
+    remove_dirs = REMOVE_DIRS
+    if cli.config.git_submodule.force:
+        # Also trash everything that isnt marked as "safe"
+        for path in Path('lib').iterdir():
+            if not any(ignore in path.as_posix() for ignore in IGNORE_DIRS):
+                remove_dirs.append(path)
+
+    for folder in map(Path, remove_dirs):
+        if folder.is_dir():
+            print(f"Removing '{folder}'")
+            shutil.rmtree(folder)
+
+    cli.run(['git', 'submodule', 'sync', '--recursive'], capture_output=False)
+    cli.run(['git', 'submodule', 'update', '--init', '--recursive', '--progress'], capture_output=False)
diff --git a/lib/python/qmk/cli/hello.py b/lib/python/qmk/cli/hello.py
new file mode 100755
index 0000000000..5119188a07
--- /dev/null
+++ b/lib/python/qmk/cli/hello.py
@@ -0,0 +1,13 @@
+"""QMK Python Hello World
+
+This is an example QMK CLI script.
+"""
+from milc import cli
+
+
+@cli.argument('-n', '--name', default='World', help='Name to greet.')
+@cli.subcommand('QMK Hello World.', hidden=False if cli.config.user.developer else True)
+def hello(cli):
+    """Log a friendly greeting.
+    """
+    cli.log.info('Hello, %s!', cli.config.hello.name)
diff --git a/lib/python/qmk/cli/import/__init__.py b/lib/python/qmk/cli/import/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/import/__init__.py
diff --git a/lib/python/qmk/cli/import/kbfirmware.py b/lib/python/qmk/cli/import/kbfirmware.py
new file mode 100644
index 0000000000..feccb3cfcc
--- /dev/null
+++ b/lib/python/qmk/cli/import/kbfirmware.py
@@ -0,0 +1,25 @@
+from milc import cli
+
+from qmk.importers import import_kbfirmware as _import_kbfirmware
+from qmk.path import FileType
+from qmk.json_schema import json_load
+
+
+@cli.argument('filename', type=FileType('r'), nargs='+', arg_only=True, help='file')
+@cli.subcommand('Import kbfirmware json export')
+def import_kbfirmware(cli):
+    filename = cli.args.filename[0]
+
+    data = json_load(filename)
+
+    cli.log.info(f'{{style_bright}}Importing {filename.name}.{{style_normal}}')
+    cli.echo('')
+
+    cli.log.warning("Support here is basic - Consider using 'qmk new-keyboard' instead")
+
+    kb_name = _import_kbfirmware(data)
+
+    cli.log.info(f'{{fg_green}}Imported a new keyboard named {{fg_cyan}}{kb_name}{{fg_green}}.{{fg_reset}}')
+    cli.log.info(f'To start working on things, `cd` into {{fg_cyan}}keyboards/{kb_name}{{fg_reset}},')
+    cli.log.info('or open the directory in your preferred text editor.')
+    cli.log.info(f"And build with {{fg_yellow}}qmk compile -kb {kb_name} -km default{{fg_reset}}.")
diff --git a/lib/python/qmk/cli/import/keyboard.py b/lib/python/qmk/cli/import/keyboard.py
new file mode 100644
index 0000000000..3a5ed37dee
--- /dev/null
+++ b/lib/python/qmk/cli/import/keyboard.py
@@ -0,0 +1,23 @@
+from milc import cli
+
+from qmk.importers import import_keyboard as _import_keyboard
+from qmk.path import FileType
+from qmk.json_schema import json_load
+
+
+@cli.argument('filename', type=FileType('r'), nargs='+', arg_only=True, help='file')
+@cli.subcommand('Import data-driven keyboard')
+def import_keyboard(cli):
+    filename = cli.args.filename[0]
+
+    data = json_load(filename)
+
+    cli.log.info(f'{{style_bright}}Importing {filename.name}.{{style_normal}}')
+    cli.echo('')
+
+    kb_name = _import_keyboard(data)
+
+    cli.log.info(f'{{fg_green}}Imported a new keyboard named {{fg_cyan}}{kb_name}{{fg_green}}.{{fg_reset}}')
+    cli.log.info(f'To start working on things, `cd` into {{fg_cyan}}keyboards/{kb_name}{{fg_reset}},')
+    cli.log.info('or open the directory in your preferred text editor.')
+    cli.log.info(f"And build with {{fg_yellow}}qmk compile -kb {kb_name} -km default{{fg_reset}}.")
diff --git a/lib/python/qmk/cli/import/keymap.py b/lib/python/qmk/cli/import/keymap.py
new file mode 100644
index 0000000000..a499c93480
--- /dev/null
+++ b/lib/python/qmk/cli/import/keymap.py
@@ -0,0 +1,23 @@
+from milc import cli
+
+from qmk.importers import import_keymap as _import_keymap
+from qmk.path import FileType
+from qmk.json_schema import json_load
+
+
+@cli.argument('filename', type=FileType('r'), nargs='+', arg_only=True, help='file')
+@cli.subcommand('Import data-driven keymap')
+def import_keymap(cli):
+    filename = cli.args.filename[0]
+
+    data = json_load(filename)
+
+    cli.log.info(f'{{style_bright}}Importing {filename.name}.{{style_normal}}')
+    cli.echo('')
+
+    kb_name, km_name = _import_keymap(data)
+
+    cli.log.info(f'{{fg_green}}Imported a new keymap named {{fg_cyan}}{km_name}{{fg_green}}.{{fg_reset}}')
+    cli.log.info(f'To start working on things, `cd` into {{fg_cyan}}keyboards/{kb_name}/keymaps/{km_name}{{fg_reset}},')
+    cli.log.info('or open the directory in your preferred text editor.')
+    cli.log.info(f"And build with {{fg_yellow}}qmk compile -kb {kb_name} -km {km_name}{{fg_reset}}.")
diff --git a/lib/python/qmk/cli/info.py b/lib/python/qmk/cli/info.py
new file mode 100755
index 0000000000..26f7f0269d
--- /dev/null
+++ b/lib/python/qmk/cli/info.py
@@ -0,0 +1,277 @@
+"""Keyboard information script.
+
+Compile an info.json for a particular keyboard and pretty-print it.
+"""
+import sys
+import json
+
+from milc import cli
+
+from qmk.json_encoders import InfoJSONEncoder
+from qmk.constants import COL_LETTERS, ROW_LETTERS
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.keyboard import keyboard_completer, keyboard_folder, render_layouts, render_layout, rules_mk
+from qmk.info import info_json, keymap_json
+from qmk.keymap import locate_keymap
+from qmk.path import is_keyboard
+
+UNICODE_SUPPORT = sys.stdout.encoding.lower().startswith('utf')
+
+
+def _strip_api_content(info_json):
+    # Ideally this would only be added in the API pathway.
+    info_json.pop('platform', None)
+    info_json.pop('platform_key', None)
+    info_json.pop('processor_type', None)
+    info_json.pop('protocol', None)
+    info_json.pop('config_h_features', None)
+    info_json.pop('keymaps', None)
+    info_json.pop('keyboard_folder', None)
+    info_json.pop('parse_errors', None)
+    info_json.pop('parse_warnings', None)
+
+    for layout in info_json.get('layouts', {}).values():
+        layout.pop('filename', None)
+        layout.pop('c_macro', None)
+        layout.pop('json_layout', None)
+
+    if 'matrix_pins' in info_json:
+        info_json.pop('matrix_size', None)
+
+    for feature in ['rgb_matrix', 'led_matrix']:
+        if info_json.get(feature, {}).get("layout", None):
+            info_json[feature].pop('led_count', None)
+
+    return info_json
+
+
+def show_keymap(kb_info_json, title_caps=True):
+    """Render the keymap in ascii art.
+    """
+    keymap_path = locate_keymap(cli.config.info.keyboard, cli.config.info.keymap)
+
+    if keymap_path and keymap_path.suffix == '.json':
+        keymap_data = json.load(keymap_path.open(encoding='utf-8'))
+
+        # cater for layout-less keymap.json
+        if 'layout' not in keymap_data:
+            return
+
+        layout_name = keymap_data['layout']
+        layout_name = kb_info_json.get('layout_aliases', {}).get(layout_name, layout_name)  # Resolve alias names
+
+        for layer_num, layer in enumerate(keymap_data['layers']):
+            if title_caps:
+                cli.echo('{fg_cyan}Keymap %s Layer %s{fg_reset}:', cli.config.info.keymap, layer_num)
+            else:
+                cli.echo('{fg_cyan}keymap.%s.layer.%s{fg_reset}:', cli.config.info.keymap, layer_num)
+
+            print(render_layout(kb_info_json['layouts'][layout_name]['layout'], cli.config.info.ascii, layer))
+
+
+def show_layouts(kb_info_json, title_caps=True):
+    """Render the layouts with info.json labels.
+    """
+    for layout_name, layout_art in render_layouts(kb_info_json, cli.config.info.ascii).items():
+        title = f'Layout {layout_name.title()}' if title_caps else f'layouts.{layout_name}'
+        cli.echo('{fg_cyan}%s{fg_reset}:', title)
+        print(layout_art)  # Avoid passing dirty data to cli.echo()
+
+
+def show_matrix(kb_info_json, title_caps=True):
+    """Render the layout with matrix labels in ascii art.
+    """
+    for layout_name, layout in kb_info_json['layouts'].items():
+        # Build our label list
+        labels = []
+        for key in layout['layout']:
+            if 'matrix' in key:
+                row = ROW_LETTERS[key['matrix'][0]]
+                col = COL_LETTERS[key['matrix'][1]]
+
+                labels.append(row + col)
+            else:
+                labels.append('')
+
+        # Print the header
+        if title_caps:
+            cli.echo('{fg_blue}Matrix for "%s"{fg_reset}:', layout_name)
+        else:
+            cli.echo('{fg_blue}matrix_%s{fg_reset}:', layout_name)
+
+        print(render_layout(kb_info_json['layouts'][layout_name]['layout'], cli.config.info.ascii, labels))
+
+
+def show_leds(kb_info_json, title_caps=True):
+    """Render LED indices per key, using the keyboard's key layout geometry.
+
+    We build a map from (row, col) -> LED index using rgb_matrix/led_matrix layout,
+    then label each key with its LED index. Keys without an associated LED are left blank.
+    """
+    # Prefer rgb_matrix, fall back to led_matrix
+    led_feature = None
+    for feature in ['rgb_matrix', 'led_matrix']:
+        if 'layout' in kb_info_json.get(feature, {}):
+            led_feature = feature
+            break
+
+    if not led_feature:
+        cli.echo('{fg_yellow}No rgb_matrix/led_matrix layout found to derive LED indices.{fg_reset}')
+        return
+
+    # Build mapping from matrix position -> LED indices for faster lookup later
+    by_matrix = {}
+    for idx, led in enumerate(kb_info_json[led_feature]['layout']):
+        if 'matrix' in led:
+            led_key = tuple(led.get('matrix'))
+            by_matrix[led_key] = idx
+
+    # For each keyboard layout (e.g., LAYOUT), render keys labeled with LED index (or blank)
+    for layout_name, layout in kb_info_json['layouts'].items():
+        labels = []
+        for key in layout['layout']:
+            led_key = tuple(key.get('matrix'))
+            label = str(by_matrix[led_key]) if led_key in by_matrix else ''
+
+            labels.append(label)
+
+        # Header
+        if title_caps:
+            cli.echo('{fg_blue}LED indices for "%s"{fg_reset}:', layout_name)
+        else:
+            cli.echo('{fg_blue}leds_%s{fg_reset}:', layout_name)
+
+        print(render_layout(kb_info_json['layouts'][layout_name]['layout'], cli.config.info.ascii, labels))
+
+
+def print_friendly_output(kb_info_json):
+    """Print the info.json in a friendly text format.
+    """
+    cli.echo('{fg_blue}Keyboard Name{fg_reset}: %s', kb_info_json.get('keyboard_name', 'Unknown'))
+    cli.echo('{fg_blue}Manufacturer{fg_reset}: %s', kb_info_json.get('manufacturer', 'Unknown'))
+    if 'url' in kb_info_json:
+        cli.echo('{fg_blue}Website{fg_reset}: %s', kb_info_json.get('url', ''))
+    if kb_info_json.get('maintainer', 'qmk') == 'qmk':
+        cli.echo('{fg_blue}Maintainer{fg_reset}: QMK Community')
+    else:
+        cli.echo('{fg_blue}Maintainer{fg_reset}: %s', kb_info_json['maintainer'])
+    cli.echo('{fg_blue}Layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys())))
+    cli.echo('{fg_blue}Processor{fg_reset}: %s', kb_info_json.get('processor', 'Unknown'))
+    cli.echo('{fg_blue}Bootloader{fg_reset}: %s', kb_info_json.get('bootloader', 'Unknown'))
+    if 'layout_aliases' in kb_info_json:
+        aliases = [f'{key}={value}' for key, value in kb_info_json['layout_aliases'].items()]
+        cli.echo('{fg_blue}Layout aliases:{fg_reset} %s' % (', '.join(aliases),))
+
+
+def print_text_output(kb_info_json):
+    """Print the info.json in a plain text format.
+    """
+    for key in sorted(kb_info_json):
+        if key == 'layouts':
+            cli.echo('{fg_blue}layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys())))
+        else:
+            cli.echo('{fg_blue}%s{fg_reset}: %s', key, kb_info_json[key])
+
+    if cli.config.info.layouts:
+        show_layouts(kb_info_json, False)
+
+    if cli.config.info.matrix:
+        show_matrix(kb_info_json, False)
+
+    if cli.config_source.info.keymap and cli.config_source.info.keymap != 'config_file':
+        show_keymap(kb_info_json, False)
+
+
+def print_dotted_output(kb_info_json, prefix=''):
+    """Print the info.json in a plain text format with dot-joined keys.
+    """
+    for key in sorted(kb_info_json):
+        new_prefix = f'{prefix}.{key}' if prefix else key
+
+        if key in ['parse_errors', 'parse_warnings']:
+            continue
+        elif key == 'layouts' and prefix == '':
+            cli.echo('{fg_blue}layouts{fg_reset}: %s', ', '.join(sorted(kb_info_json['layouts'].keys())))
+        elif isinstance(kb_info_json[key], dict):
+            print_dotted_output(kb_info_json[key], new_prefix)
+        elif isinstance(kb_info_json[key], list):
+            cli.echo('{fg_blue}%s{fg_reset}: %s', new_prefix, ', '.join(map(str, sorted(kb_info_json[key]))))
+        else:
+            cli.echo('{fg_blue}%s{fg_reset}: %s', new_prefix, kb_info_json[key])
+
+
+def print_parsed_rules_mk(keyboard_name):
+    rules = rules_mk(keyboard_name)
+    for k in sorted(rules.keys()):
+        print('%s = %s' % (k, rules[k]))
+    return
+
+
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='Keyboard to show info for.')
+@cli.argument('-km', '--keymap', help='Keymap to show info for (Optional).')
+@cli.argument('-l', '--layouts', action='store_true', help='Render the layouts.')
+@cli.argument('-m', '--matrix', action='store_true', help='Render the layouts with matrix information.')
+@cli.argument('-L', '--leds', action='store_true', help='Render the LED layout with LED indices (rgb_matrix/led_matrix).')
+@cli.argument('-f', '--format', default='friendly', arg_only=True, help='Format to display the data in (friendly, text, json) (Default: friendly).')
+@cli.argument('--ascii', action='store_true', default=not UNICODE_SUPPORT, help='Render layout box drawings in ASCII only.')
+@cli.argument('-r', '--rules-mk', action='store_true', help='Render the parsed values of the keyboard\'s rules.mk file.')
+@cli.argument('-a', '--api', action='store_true', help='Show fully processed info intended for API consumption.')
+@cli.subcommand('Keyboard information.')
+@automagic_keyboard
+@automagic_keymap
+def info(cli):
+    """Compile an info.json for a particular keyboard and pretty-print it.
+    """
+    # Determine our keyboard(s)
+    if not cli.config.info.keyboard:
+        cli.log.error('Missing parameter: --keyboard')
+        cli.subcommands['info'].print_help()
+        return False
+
+    if not is_keyboard(cli.config.info.keyboard):
+        cli.log.error('Invalid keyboard: "%s"', cli.config.info.keyboard)
+        return False
+
+    if bool(cli.args.rules_mk):
+        print_parsed_rules_mk(cli.config.info.keyboard)
+        return False
+
+    # default keymap stored in config file should be ignored
+    if cli.config_source.info.keymap == 'config_file':
+        cli.config_source.info.keymap = None
+
+    # Build the info.json file
+    if cli.config.info.keymap:
+        kb_info_json = keymap_json(cli.config.info.keyboard, cli.config.info.keymap)
+    else:
+        kb_info_json = info_json(cli.config.info.keyboard)
+
+    if not cli.args.api:
+        kb_info_json = _strip_api_content(kb_info_json)
+
+    # Output in the requested format
+    if cli.args.format == 'json':
+        print(json.dumps(kb_info_json, cls=InfoJSONEncoder, sort_keys=True))
+        return True
+    elif cli.args.format == 'text':
+        print_dotted_output(kb_info_json)
+        title_caps = False
+    elif cli.args.format == 'friendly':
+        print_friendly_output(kb_info_json)
+        title_caps = True
+    else:
+        cli.log.error('Unknown format: %s', cli.args.format)
+        return False
+
+    # Output requested extras
+    if cli.config.info.layouts:
+        show_layouts(kb_info_json, title_caps)
+
+    if cli.config.info.matrix:
+        show_matrix(kb_info_json, title_caps)
+
+    if cli.config.info.leds:
+        show_leds(kb_info_json, title_caps)
+
+    if cli.config.info.keymap:
+        show_keymap(kb_info_json, title_caps)
diff --git a/lib/python/qmk/cli/json2c.py b/lib/python/qmk/cli/json2c.py
new file mode 100755
index 0000000000..a2db314947
--- /dev/null
+++ b/lib/python/qmk/cli/json2c.py
@@ -0,0 +1,28 @@
+"""Generate a keymap.c from a configurator export.
+"""
+from argcomplete.completers import FilesCompleter
+from milc import cli
+
+import qmk.keymap
+import qmk.path
+from qmk.commands import dump_lines, parse_configurator_json
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('filename', type=qmk.path.FileType('r'), arg_only=True, completer=FilesCompleter('.json'), help='Configurator JSON file')
+@cli.subcommand('Creates a keymap.c from a QMK Configurator export.')
+def json2c(cli):
+    """Generate a keymap.c from a configurator export.
+
+    This command uses the `qmk.keymap` module to generate a keymap.c from a configurator export. The generated keymap is written to stdout, or to a file if -o is provided.
+    """
+
+    # Parse the configurator from json file (or stdin)
+    user_keymap = parse_configurator_json(cli.args.filename)
+
+    # Generate the keymap
+    keymap_c = qmk.keymap.generate_c(user_keymap)
+
+    # Show the results
+    dump_lines(cli.args.output, keymap_c.split('\n'), cli.args.quiet)
diff --git a/lib/python/qmk/cli/kle2json.py b/lib/python/qmk/cli/kle2json.py
new file mode 100755
index 0000000000..bbfddf4268
--- /dev/null
+++ b/lib/python/qmk/cli/kle2json.py
@@ -0,0 +1,59 @@
+"""Convert raw KLE to JSON
+"""
+import json
+import os
+from pathlib import Path
+
+from argcomplete.completers import FilesCompleter
+from milc import cli
+from kle2xy import KLE2xy
+
+from qmk.converter import kle2qmk
+from qmk.json_encoders import InfoJSONEncoder
+
+
+@cli.argument('filename', completer=FilesCompleter('.json'), help='The KLE raw txt to convert')
+@cli.argument('-f', '--force', action='store_true', help='Flag to overwrite current info.json')
+@cli.subcommand('Convert a KLE layout to a Configurator JSON', hidden=False if cli.config.user.developer else True)
+def kle2json(cli):
+    """Convert a KLE layout to QMK's layout format.
+    """  # If filename is a path
+    if cli.args.filename.startswith("/") or cli.args.filename.startswith("./"):
+        file_path = Path(cli.args.filename)
+    # Otherwise assume it is a file name
+    else:
+        file_path = Path(os.environ['ORIG_CWD'], cli.args.filename)
+    # Check for valid file_path for more graceful failure
+    if not file_path.exists():
+        cli.log.error('File {fg_cyan}%s{style_reset_all} was not found.', file_path)
+        return False
+    out_path = file_path.parent
+    raw_code = file_path.read_text(encoding='utf-8')
+    # Check if info.json exists, allow overwrite with force
+    if Path(out_path, "info.json").exists() and not cli.args.force:
+        cli.log.error('File {fg_cyan}%s/info.json{style_reset_all} already exists, use -f or --force to overwrite.', out_path)
+        return False
+    try:
+        # Convert KLE raw to x/y coordinates (using kle2xy package from skullydazed)
+        kle = KLE2xy(raw_code)
+    except Exception as e:
+        cli.log.error('Could not parse KLE raw data: %s', raw_code)
+        cli.log.exception(e)
+        return False
+    keyboard = {
+        'keyboard_name': kle.name,
+        'url': '',
+        'maintainer': 'qmk',
+        'layouts': {
+            'LAYOUT': {
+                'layout': kle2qmk(kle)
+            }
+        },
+    }
+
+    # Write our info.json
+    keyboard = json.dumps(keyboard, indent=4, separators=(', ', ': '), sort_keys=False, cls=InfoJSONEncoder)
+    info_json_file = out_path / 'info.json'
+
+    info_json_file.write_text(keyboard)
+    cli.log.info('Wrote out {fg_cyan}%s/info.json', out_path)
diff --git a/lib/python/qmk/cli/license_check.py b/lib/python/qmk/cli/license_check.py
new file mode 100644
index 0000000000..119a228c6d
--- /dev/null
+++ b/lib/python/qmk/cli/license_check.py
@@ -0,0 +1,131 @@
+# Copyright 2023 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+import re
+from milc import cli
+from qmk.constants import LICENSE_TEXTS
+from qmk.path import normpath
+
+L_PAREN = re.compile(r'\(\[\{\<')
+R_PAREN = re.compile(r'\)\]\}\>')
+PUNCTUATION = re.compile(r'[\.,;:]+')
+TRASH_PREFIX = re.compile(r'^(\s|/|\*|#)+')
+TRASH_SUFFIX = re.compile(r'(\s|/|\*|#|\\)+$')
+SPACE = re.compile(r'\s+')
+SUFFIXES = ['.c', '.h', '.cpp', '.cxx', '.hpp', '.hxx']
+
+
+def _simplify_text(input):
+    lines = input.lower().split('\n')
+    lines = [PUNCTUATION.sub('', line) for line in lines]
+    lines = [TRASH_PREFIX.sub('', line) for line in lines]
+    lines = [TRASH_SUFFIX.sub('', line) for line in lines]
+    lines = [SPACE.sub(' ', line) for line in lines]
+    lines = [L_PAREN.sub('(', line) for line in lines]
+    lines = [R_PAREN.sub(')', line) for line in lines]
+    lines = [line.strip() for line in lines]
+    lines = [line for line in lines if line is not None and line != '']
+    return ' '.join(lines)
+
+
+def _preformat_license_texts():
+    # Pre-format all the licenses
+    for _, long_licenses in LICENSE_TEXTS:
+        for i in range(len(long_licenses)):
+            long_licenses[i] = _simplify_text(long_licenses[i])
+
+
+def _determine_suffix_condition(extensions):
+    def _default_suffix_condition(s):
+        return s in SUFFIXES
+
+    conditional = _default_suffix_condition
+
+    if extensions is not None and len(extensions) > 0:
+        suffixes = [f'.{s}' if not s.startswith('.') else s for s in extensions]
+
+        def _specific_suffix_condition(s):
+            return s in suffixes
+
+        conditional = _specific_suffix_condition
+
+    return conditional
+
+
+def _determine_file_list(inputs, conditional):
+    check_list = set()
+    for filename in inputs:
+        if filename.is_dir():
+            for file in sorted(filename.rglob('*')):
+                if file.is_file() and conditional(file.suffix):
+                    check_list.add(file)
+        elif filename.is_file():
+            if conditional(filename.suffix):
+                check_list.add(filename)
+
+    return list(sorted(check_list))
+
+
+def _detect_license_from_file_contents(filename, absolute=False, short=False):
+    data = filename.read_text(encoding='utf-8', errors='ignore')
+    filename_out = str(filename.absolute()) if absolute else str(filename)
+
+    if 'SPDX-License-Identifier:' in data:
+        res = data.split('SPDX-License-Identifier:')
+        license = re.split(r'\s|//|\*', res[1].strip())[0].strip()
+        found = False
+        for short_license, _ in LICENSE_TEXTS:
+            if license.lower() == short_license.lower():
+                license = short_license
+                found = True
+                break
+
+        if not found:
+            if short:
+                print(f'{filename_out} UNKNOWN')
+            else:
+                cli.log.error(f'{{fg_cyan}}{filename_out}{{fg_reset}} -- unknown license, or no license detected!')
+            return False
+
+        if short:
+            print(f'{filename_out} {license}')
+        else:
+            cli.log.info(f'{{fg_cyan}}{filename_out}{{fg_reset}} -- license detected: {license} (SPDX License Identifier)')
+        return True
+
+    else:
+        simple_text = _simplify_text(data)
+        for short_license, long_licenses in LICENSE_TEXTS:
+            for long_license in long_licenses:
+                if long_license in simple_text:
+                    if short:
+                        print(f'{filename_out} {short_license}')
+                    else:
+                        cli.log.info(f'{{fg_cyan}}{filename_out}{{fg_reset}} -- license detected: {short_license} (Full text)')
+                    return True
+
+        if short:
+            print(f'{filename_out} UNKNOWN')
+        else:
+            cli.log.error(f'{{fg_cyan}}{filename_out}{{fg_reset}} -- unknown license, or no license detected!')
+
+    return False
+
+
+@cli.argument('inputs', nargs='*', arg_only=True, type=normpath, help='List of input files or directories.')
+@cli.argument('-s', '--short', action='store_true', help='Short output.')
+@cli.argument('-a', '--absolute', action='store_true', help='Print absolute paths.')
+@cli.argument('-e', '--extension', arg_only=True, action='append', default=[], help='Override list of extensions. Can be specified multiple times for multiple extensions.')
+@cli.subcommand('File license check.', hidden=False if cli.config.user.developer else True)
+def license_check(cli):
+    _preformat_license_texts()
+
+    conditional = _determine_suffix_condition(cli.args.extension)
+    check_list = _determine_file_list(cli.args.inputs, conditional)
+
+    failed = False
+    for filename in sorted(check_list):
+        if not _detect_license_from_file_contents(filename, absolute=cli.args.absolute, short=cli.args.short):
+            failed = True
+
+    if failed:
+        return False
diff --git a/lib/python/qmk/cli/lint.py b/lib/python/qmk/cli/lint.py
new file mode 100644
index 0000000000..8a128ce6d2
--- /dev/null
+++ b/lib/python/qmk/cli/lint.py
@@ -0,0 +1,406 @@
+"""Command to look over a keyboard/keymap and check for common mistakes.
+"""
+from dotty_dict import dotty
+from pathlib import Path
+
+from milc import cli
+
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.info import info_json
+from qmk.keyboard import keyboard_completer, keyboard_folder_or_all, is_all_keyboards, list_keyboards
+from qmk.keymap import locate_keymap, list_keymaps
+from qmk.path import keyboard
+from qmk.git import git_get_ignored_files
+from qmk.c_parse import c_source_files, preprocess_c_file
+from qmk.json_schema import json_load
+
+CHIBIOS_CONF_CHECKS = ['chconf.h', 'halconf.h', 'mcuconf.h', 'board.h']
+INVALID_KB_FEATURES = set(['encoder_map', 'dip_switch_map', 'combo', 'tap_dance', 'via'])
+INVALID_KM_NAMES = ['via', 'vial']
+
+
+def _list_defaultish_keymaps(kb):
+    """Return default like keymaps for a given keyboard
+    """
+    defaultish = ['ansi', 'iso']
+
+    # This is only here to flag it as "testable", so it doesn't fly under the radar during PR
+    defaultish.extend(INVALID_KM_NAMES)
+
+    keymaps = set()
+    for x in list_keymaps(kb, include_userspace=False):
+        if x in defaultish or x.startswith('default'):
+            keymaps.add(x)
+
+    return keymaps
+
+
+def _get_readme_files(kb, km=None):
+    """Return potential keyboard/keymap readme files
+    """
+    search_path = locate_keymap(kb, km).parent if km else keyboard(kb)
+
+    readme_files = []
+
+    if not km:
+        current_path = Path(search_path.parts[0])
+        for path_part in search_path.parts[1:]:
+            current_path = current_path / path_part
+            readme_files.extend(current_path.glob('*readme.md'))
+
+    for file in search_path.glob("**/*readme.md"):
+        # Ignore keymaps when only globing keyboard files
+        if not km and 'keymaps' in file.parts:
+            continue
+        readme_files.append(file)
+
+    return set(readme_files)
+
+
+def _get_build_files(kb, km=None):
+    """Return potential keyboard/keymap build files
+    """
+    search_path = locate_keymap(kb, km).parent if km else keyboard(kb)
+
+    build_files = []
+
+    if not km:
+        current_path = Path()
+        for path_part in search_path.parts:
+            current_path = current_path / path_part
+            build_files.extend(current_path.glob('*rules.mk'))
+
+    for file in search_path.glob("**/*rules.mk"):
+        # Ignore keymaps when only globing keyboard files
+        if not km and 'keymaps' in file.parts:
+            continue
+        build_files.append(file)
+
+    return set(build_files)
+
+
+def _get_code_files(kb, km=None):
+    """Return potential keyboard/keymap code files
+    """
+    search_path = locate_keymap(kb, km).parent if km else keyboard(kb)
+
+    code_files = []
+
+    if not km:
+        current_path = Path()
+        for path_part in search_path.parts:
+            current_path = current_path / path_part
+            code_files.extend(current_path.glob('*.h'))
+            code_files.extend(current_path.glob('*.c'))
+
+    for file in c_source_files([search_path]):
+        # Ignore keymaps when only globing keyboard files
+        if not km and 'keymaps' in file.parts:
+            continue
+        code_files.append(file)
+
+    return code_files
+
+
+def _is_invalid_readme(file):
+    """Check if file contains any unfilled content
+    """
+    tokens = [
+        '%KEYBOARD%',
+        '%REAL_NAME%',
+        '%USER_NAME%',
+        'image replace me!',
+        'A short description of the keyboard/project',
+        'The PCBs, controllers supported',
+        'Links to where you can find this hardware',
+    ]
+
+    for line in file.read_text(encoding='utf-8').split("\n"):
+        if any(token in line for token in tokens):
+            return True
+    return False
+
+
+def _is_empty_rules(file):
+    """Check if file contains any useful content
+    """
+    for line in file.read_text(encoding='utf-8').split("\n"):
+        if len(line) > 0 and not line.isspace() and not line.startswith('#'):
+            return False
+    return True
+
+
+def _is_empty_include(file):
+    """Check if file contains any useful content
+    """
+    for line in preprocess_c_file(file).split("\n"):
+        if len(line) > 0 and not line.isspace() and not line.startswith('#pragma once'):
+            return False
+    return True
+
+
+def _has_license(file):
+    """Check file has a license header
+    """
+    # Crude assumption that first line of license header is a comment
+    fline = open(file).readline().rstrip()
+    return fline.startswith(("/*", "//"))
+
+
+def _handle_json_errors(kb, info):
+    """Convert any json errors into lint errors
+    """
+    ok = True
+    # Check for errors in the json
+    if info['parse_errors']:
+        ok = False
+        cli.log.error(f'{kb}: Errors found when generating info.json.')
+
+    if cli.config.lint.strict and info['parse_warnings']:
+        ok = False
+        cli.log.error(f'{kb}: Warnings found when generating info.json (Strict mode enabled.)')
+    return ok
+
+
+def _handle_invalid_features(kb, info):
+    """Check for features that should never be enabled at the keyboard level
+    """
+    ok = True
+    features = set(info.get('features', []))
+    for found in features & INVALID_KB_FEATURES:
+        ok = False
+        cli.log.error(f'{kb}: Invalid keyboard level feature detected - {found}')
+    return ok
+
+
+def _handle_invalid_config(kb, info):
+    """Check for invalid keyboard level config
+    """
+    if info.get('url') == "":
+        cli.log.warning(f'{kb}: Invalid keyboard level config detected - Optional field "url" should not be empty.')
+    return True
+
+
+def _chibios_conf_includenext_check(target):
+    """Check the ChibiOS conf.h for the correct inclusion of the next conf.h
+    """
+    for i, line in enumerate(target.open()):
+        if f'#include_next "{target.name}"' in line:
+            return f'Found `#include_next "{target.name}"` on line {i} of {target}, should be `#include_next <{target.name}>` (use angle brackets, not quotes)'
+    return None
+
+
+def _rules_mk_assignment_only(rules_mk):
+    """Check the keyboard-level rules.mk to ensure it only has assignments.
+    """
+    errors = []
+    continuation = None
+    for i, line in enumerate(rules_mk.open()):
+        line = line.strip()
+
+        if '#' in line:
+            line = line[:line.index('#')]
+
+        if continuation:
+            line = continuation + line
+            continuation = None
+
+        if line:
+            if line[-1] == '\\':
+                continuation = line[:-1]
+                continue
+
+            if line and '=' not in line:
+                errors.append(f'Non-assignment code on line +{i} {rules_mk}: {line}')
+
+    return errors
+
+
+def _handle_duplicating_code_defaults(kb, info):
+    def _collect_dotted_output(kb_info_json, prefix=''):
+        """Print the info.json in a plain text format with dot-joined keys.
+        """
+        for key in sorted(kb_info_json):
+            new_prefix = f'{prefix}.{key}' if prefix else key
+
+            if isinstance(kb_info_json[key], dict):
+                yield from _collect_dotted_output(kb_info_json[key], new_prefix)
+            elif isinstance(kb_info_json[key], list):
+                # TODO: handle non primitives?
+                yield (new_prefix, kb_info_json[key])
+            else:
+                yield (new_prefix, kb_info_json[key])
+
+    defaults_map = json_load(Path('data/mappings/info_defaults.hjson'))
+    dotty_info = dotty(info)
+
+    for key, v_default in _collect_dotted_output(defaults_map):
+        v_info = dotty_info.get(key)
+        if v_default == v_info:
+            cli.log.warning(f'{kb}: Option "{key}" duplicates default value of "{v_default}"')
+
+    return True
+
+
+def keymap_check(kb, km):
+    """Perform the keymap level checks.
+    """
+    ok = True
+    keymap_path = locate_keymap(kb, km)
+
+    if not keymap_path:
+        ok = False
+        cli.log.error("%s: Can't find %s keymap.", kb, km)
+        return ok
+
+    if km in INVALID_KM_NAMES:
+        ok = False
+        cli.log.error("%s: The keymap %s should not exist!", kb, km)
+        return ok
+
+    # Additional checks
+    invalid_files = git_get_ignored_files(keymap_path.parent.as_posix())
+    for file in invalid_files:
+        cli.log.error(f'{kb}/{km}: The file "{file}" should not exist!')
+        ok = False
+
+    for file in _get_code_files(kb, km):
+        if not _has_license(file):
+            cli.log.error(f'{kb}/{km}: The file "{file}" does not have a license header!')
+            ok = False
+
+        if file.name in CHIBIOS_CONF_CHECKS:
+            check_error = _chibios_conf_includenext_check(file)
+            if check_error is not None:
+                cli.log.error(f'{kb}/{km}: {check_error}')
+                ok = False
+
+    return ok
+
+
+def keyboard_check(kb):  # noqa C901
+    """Perform the keyboard level checks.
+    """
+    ok = True
+    kb_info = info_json(kb)
+
+    if not _handle_json_errors(kb, kb_info):
+        ok = False
+
+    # Additional checks
+    if not _handle_invalid_features(kb, kb_info):
+        ok = False
+
+    if not _handle_invalid_config(kb, kb_info):
+        ok = False
+
+    if not _handle_duplicating_code_defaults(kb, kb_info):
+        ok = False
+
+    invalid_files = git_get_ignored_files(f'keyboards/{kb}/')
+    for file in invalid_files:
+        if 'keymap' in file:
+            continue
+        cli.log.error(f'{kb}: The file "{file}" should not exist!')
+        ok = False
+
+    if not _get_readme_files(kb):
+        cli.log.error(f'{kb}: Is missing a readme.md file!')
+        ok = False
+
+    for file in _get_readme_files(kb):
+        if _is_invalid_readme(file):
+            cli.log.error(f'{kb}: The file "{file}" still contains template tokens!')
+            ok = False
+
+    for file in _get_build_files(kb):
+        if _is_empty_rules(file):
+            cli.log.error(f'{kb}: The file "{file}" is effectively empty and should be removed!')
+            ok = False
+
+        if file.suffix in ['rules.mk']:
+            rules_mk_assignment_errors = _rules_mk_assignment_only(file)
+            if rules_mk_assignment_errors:
+                ok = False
+                cli.log.error('%s: Non-assignment code found in rules.mk. Move it to post_rules.mk instead.', kb)
+                for assignment_error in rules_mk_assignment_errors:
+                    cli.log.error(assignment_error)
+
+    for file in _get_code_files(kb):
+        if not _has_license(file):
+            cli.log.error(f'{kb}: The file "{file}" does not have a license header!')
+            ok = False
+
+        if file.name in ['config.h']:
+            if _is_empty_include(file):
+                cli.log.error(f'{kb}: The file "{file}" is effectively empty and should be removed!')
+                ok = False
+
+        if file.name in CHIBIOS_CONF_CHECKS:
+            check_error = _chibios_conf_includenext_check(file)
+            if check_error is not None:
+                cli.log.error(f'{kb}: {check_error}')
+                ok = False
+
+    return ok
+
+
+@cli.argument('--strict', action='store_true', help='Treat warnings as errors')
+@cli.argument('-kb', '--keyboard', action='append', type=keyboard_folder_or_all, completer=keyboard_completer, help='Keyboard to check. May be passed multiple times.')
+@cli.argument('-km', '--keymap', help='The keymap to check')
+@cli.subcommand('Check keyboard and keymap for common mistakes.')
+@automagic_keyboard
+@automagic_keymap
+def lint(cli):
+    """Check keyboard and keymap for common mistakes.
+    """
+    # Determine our keyboard list
+    if not cli.config.lint.keyboard:
+        cli.log.error('Missing required arguments: --keyboard')
+        cli.print_help()
+        return False
+
+    if isinstance(cli.config.lint.keyboard, str):
+        # if provided via config - string not array
+        keyboard_list = [cli.config.lint.keyboard]
+    elif any(is_all_keyboards(kb) for kb in cli.args.keyboard):
+        keyboard_list = list_keyboards()
+    else:
+        keyboard_list = list(set(cli.config.lint.keyboard))
+
+    failed = []
+
+    # Lint each keyboard
+    for kb in keyboard_list:
+        # Determine keymaps to also check
+        if cli.args.keymap == 'all':
+            keymaps = list_keymaps(kb)
+        elif cli.config.lint.keymap:
+            keymaps = {cli.config.lint.keymap}
+        else:
+            keymaps = _list_defaultish_keymaps(kb)
+            # Ensure that at least a 'default' keymap always exists
+            keymaps.add('default')
+
+        ok = True
+
+        # keyboard level checks
+        if not keyboard_check(kb):
+            ok = False
+
+        # Keymap specific checks
+        for keymap in keymaps:
+            if not keymap_check(kb, keymap):
+                ok = False
+
+        # Report status
+        if not ok:
+            failed.append(kb)
+
+    # Check and report the overall status
+    if failed:
+        cli.log.error('Lint check failed for: %s', ', '.join(failed))
+        return False
+
+    cli.log.info('Lint check passed!')
+    return True
diff --git a/lib/python/qmk/cli/list/__init__.py b/lib/python/qmk/cli/list/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/list/__init__.py
diff --git a/lib/python/qmk/cli/list/keyboards.py b/lib/python/qmk/cli/list/keyboards.py
new file mode 100644
index 0000000000..8b6c451673
--- /dev/null
+++ b/lib/python/qmk/cli/list/keyboards.py
@@ -0,0 +1,13 @@
+"""List the keyboards currently defined within QMK
+"""
+from milc import cli
+
+import qmk.keyboard
+
+
+@cli.subcommand("List the keyboards currently defined within QMK")
+def list_keyboards(cli):
+    """List the keyboards currently defined within QMK
+    """
+    for keyboard_name in qmk.keyboard.list_keyboards():
+        print(keyboard_name)
diff --git a/lib/python/qmk/cli/list/keymaps.py b/lib/python/qmk/cli/list/keymaps.py
new file mode 100644
index 0000000000..d2ef136c06
--- /dev/null
+++ b/lib/python/qmk/cli/list/keymaps.py
@@ -0,0 +1,22 @@
+"""List the keymaps for a specific keyboard
+"""
+from milc import cli
+
+import qmk.keymap
+from qmk.decorators import automagic_keyboard
+from qmk.keyboard import keyboard_completer, keyboard_folder
+
+
+@cli.argument("-kb", "--keyboard", type=keyboard_folder, completer=keyboard_completer, help="Specify keyboard name. Example: 1upkeyboards/1up60hse")
+@cli.subcommand("List the keymaps for a specific keyboard")
+@automagic_keyboard
+def list_keymaps(cli):
+    """List the keymaps for a specific keyboard
+    """
+    if not cli.config.list_keymaps.keyboard:
+        cli.log.error('Missing required arguments: --keyboard')
+        cli.subcommands['list-keymaps'].print_help()
+        return False
+
+    for name in qmk.keymap.list_keymaps(cli.config.list_keymaps.keyboard):
+        print(name)
diff --git a/lib/python/qmk/cli/list/layouts.py b/lib/python/qmk/cli/list/layouts.py
new file mode 100644
index 0000000000..df593dc390
--- /dev/null
+++ b/lib/python/qmk/cli/list/layouts.py
@@ -0,0 +1,23 @@
+"""List the keymaps for a specific keyboard
+"""
+from milc import cli
+
+from qmk.decorators import automagic_keyboard
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.info import info_json
+
+
+@cli.argument("-kb", "--keyboard", type=keyboard_folder, completer=keyboard_completer, help="Specify keyboard name. Example: monarch")
+@cli.subcommand("List the layouts for a specific keyboard")
+@automagic_keyboard
+def list_layouts(cli):
+    """List the layouts for a specific keyboard
+    """
+    if not cli.config.list_layouts.keyboard:
+        cli.log.error('Missing required arguments: --keyboard')
+        cli.subcommands['list-layouts'].print_help()
+        return False
+
+    info_data = info_json(cli.config.list_layouts.keyboard)
+    for name in sorted(info_data.get('community_layouts', [])):
+        print(name)
diff --git a/lib/python/qmk/cli/mass_compile.py b/lib/python/qmk/cli/mass_compile.py
new file mode 100755
index 0000000000..e71280f482
--- /dev/null
+++ b/lib/python/qmk/cli/mass_compile.py
@@ -0,0 +1,151 @@
+"""Compile all keyboards.
+
+This will compile everything in parallel, for testing purposes.
+"""
+import os
+from typing import List
+from pathlib import Path
+from subprocess import DEVNULL
+from milc import cli
+import shlex
+
+from qmk.constants import QMK_FIRMWARE
+from qmk.commands import find_make, get_make_parallel_args, build_environment
+from qmk.search import search_keymap_targets, search_make_targets
+from qmk.build_targets import BuildTarget, JsonKeymapBuildTarget
+from qmk.util import maybe_exit_config
+
+
+def mass_compile_targets(targets: List[BuildTarget], clean: bool, dry_run: bool, no_temp: bool, parallel: int, print_failures: bool, **env):
+    if len(targets) == 0:
+        return
+
+    os.environ.setdefault('SKIP_SCHEMA_VALIDATION', '1')
+
+    make_cmd = find_make()
+    builddir = Path(QMK_FIRMWARE) / '.build'
+    makefile = builddir / 'parallel_kb_builds.mk'
+
+    if dry_run:
+        cli.log.info('Compilation targets:')
+        for target in sorted(targets, key=lambda t: (t.keyboard, t.keymap)):
+            extra_args = ' '.join([f"-e {shlex.quote(f'{k}={v}')}" for k, v in target.extra_args.items()])
+            cli.log.info(f"{{fg_cyan}}qmk compile -kb {target.keyboard} -km {target.keymap} {extra_args}{{fg_reset}}")
+    else:
+        if clean:
+            cli.run([make_cmd, 'clean'], capture_output=False, stdin=DEVNULL)
+
+        builddir.mkdir(parents=True, exist_ok=True)
+        with open(makefile, "w") as f:
+            # yapf: disable
+            f.write(
+                f"""\
+# This file is auto-generated by qmk mass-compile
+# Do not edit this file directly.
+all: print_failures
+.PHONY: all_targets print_failures
+print_failures: all_targets
+"""# noqa
+            )
+            if print_failures:
+                f.write(
+                    f"""\
+        @for f in $$(ls .build/failed.log.{os.getpid()}.* 2>/dev/null | sort); do \\
+                echo; \\
+                echo "======================================================================================"; \\
+                echo "Failed build log: $$f"; \\
+                echo "------------------------------------------------------"; \\
+                cat $$f; \\
+                echo "------------------------------------------------------"; \\
+        done
+"""# noqa
+                )
+            # yapf: enable
+            for target in sorted(targets, key=lambda t: (t.keyboard, t.keymap)):
+                keyboard_name = target.keyboard
+                keymap_name = target.keymap
+                keyboard_safe = keyboard_name.replace('/', '_')
+                target_filename = target.target_name(**env)
+                target.configure(parallel=1)  # We ignore parallelism on a per-build basis as we defer to the parent make invocation
+                target.prepare_build(**env)  # If we've got json targets, allow them to write out any extra info to .build before we kick off `make`
+                command = target.compile_command(**env)
+                command[0] = '+@$(MAKE)'  # Override the make so that we can use jobserver to handle parallelism
+                extra_args = '_'.join([f"{k}_{v}" for k, v in target.extra_args.items()])
+                build_log = f"{QMK_FIRMWARE}/.build/build.log.{os.getpid()}.{keyboard_safe}.{keymap_name}"
+                failed_log = f"{QMK_FIRMWARE}/.build/failed.log.{os.getpid()}.{keyboard_safe}.{keymap_name}"
+                target_suffix = ''
+                if len(extra_args) > 0:
+                    build_log += f".{extra_args}"
+                    failed_log += f".{extra_args}"
+                    target_suffix = f"_{extra_args}"
+                # yapf: disable
+                f.write(
+                    f"""\
+.PHONY: {target_filename}{target_suffix}_binary
+all_targets: {target_filename}{target_suffix}_binary
+{target_filename}{target_suffix}_binary:
+        @rm -f "{build_log}" || true
+        @echo "Compiling QMK Firmware for target: '{keyboard_name}:{keymap_name}'..." >>"{build_log}"
+        {' '.join(command)} \\
+                >>"{build_log}" 2>&1 \\
+                || cp "{build_log}" "{failed_log}"
+        @{{ grep '\\[ERRORS\\]' "{build_log}" >/dev/null 2>&1 && printf "Build %-64s \\e[1;31m[ERRORS]\\e[0m\\n" "{keyboard_name}:{keymap_name}" ; }} \\
+                || {{ grep '\\[WARNINGS\\]' "{build_log}" >/dev/null 2>&1 && printf "Build %-64s \\e[1;33m[WARNINGS]\\e[0m\\n" "{keyboard_name}:{keymap_name}" ; }} \\
+                || printf "Build %-64s \\e[1;32m[OK]\\e[0m\\n" "{keyboard_name}:{keymap_name}"
+        @rm -f "{build_log}" || true
+"""# noqa
+                )
+                # yapf: enable
+
+                if no_temp:
+                    # yapf: disable
+                    f.write(
+                        f"""\
+        @rm -rf "{QMK_FIRMWARE}/.build/{target_filename}.elf" 2>/dev/null || true
+        @rm -rf "{QMK_FIRMWARE}/.build/{target_filename}.map" 2>/dev/null || true
+        @rm -rf "{QMK_FIRMWARE}/.build/obj_{target_filename}" || true
+"""# noqa
+                    )
+                    # yapf: enable
+                f.write('\n')
+
+        cli.run([find_make(), *get_make_parallel_args(parallel), '-f', makefile.as_posix(), 'all'], capture_output=False, stdin=DEVNULL)
+
+        # Check for failures
+        failures = [f for f in builddir.glob(f'failed.log.{os.getpid()}.*')]
+        if len(failures) > 0:
+            return False
+
+
+@cli.argument('builds', nargs='*', arg_only=True, help="List of builds in form <keyboard>:<keymap> to compile in parallel. Specifying this overrides all other target search options.")
+@cli.argument('-t', '--no-temp', arg_only=True, action='store_true', help="Remove temporary files during build.")
+@cli.argument('-j', '--parallel', type=int, default=1, help="Set the number of parallel make jobs; 0 means unlimited.")
+@cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.")
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't actually build, just show the commands to be run.")
+@cli.argument('-p', '--print-failures', arg_only=True, action='store_true', help="Print failed builds.")
+@cli.argument(
+    '-f',
+    '--filter',
+    arg_only=True,
+    action='append',
+    default=[],
+    help=  # noqa: `format-python` and `pytest` don't agree here.
+    "Filter the list of keyboards based on the supplied value in rules.mk. Matches info.json structure, and accepts the formats 'features.rgblight=true' or 'exists(matrix_pins.direct)'. May be passed multiple times, all filters need to match. Value may include wildcards such as '*' and '?'."  # noqa: `format-python` and `pytest` don't agree here.
+)
+@cli.argument('-km', '--keymap', type=str, default='default', help="The keymap name to build. Default is 'default'.")
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.")
+@cli.subcommand('Compile QMK Firmware for all keyboards.', hidden=False if cli.config.user.developer else True)
+def mass_compile(cli):
+    """Compile QMK Firmware against all keyboards.
+    """
+    maybe_exit_config(should_exit=False, should_reraise=True)
+
+    if len(cli.args.builds) > 0:
+        json_like_targets = list([Path(p) for p in filter(lambda e: Path(e).exists() and Path(e).suffix == '.json', cli.args.builds)])
+        make_like_targets = list(filter(lambda e: Path(e) not in json_like_targets, cli.args.builds))
+        targets = search_make_targets(make_like_targets)
+        targets.extend([JsonKeymapBuildTarget(e) for e in json_like_targets])
+    else:
+        targets = search_keymap_targets([('all', cli.config.mass_compile.keymap)], cli.args.filter)
+
+    return mass_compile_targets(targets, cli.args.clean, cli.args.dry_run, cli.args.no_temp, cli.config.mass_compile.parallel, cli.args.print_failures, **build_environment(cli.args.env))
diff --git a/lib/python/qmk/cli/migrate.py b/lib/python/qmk/cli/migrate.py
new file mode 100644
index 0000000000..d0f195d737
--- /dev/null
+++ b/lib/python/qmk/cli/migrate.py
@@ -0,0 +1,84 @@
+"""Migrate keyboard configuration to "Data Driven"
+"""
+import json
+from pathlib import Path
+from dotty_dict import dotty
+
+from milc import cli
+
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.info import info_json, find_info_json
+from qmk.json_encoders import InfoJSONEncoder
+from qmk.json_schema import json_load
+
+
+def _candidate_files(keyboard):
+    kb_dir = Path(keyboard)
+
+    cur_dir = Path('keyboards')
+    files = []
+    for dir in kb_dir.parts:
+        cur_dir = cur_dir / dir
+        files.append(cur_dir / 'config.h')
+        files.append(cur_dir / 'rules.mk')
+
+    return [file for file in files if file.exists()]
+
+
+@cli.argument('-f', '--filter', arg_only=True, action='append', default=[], help="Filter the performed migrations based on the supplied value. Supported format is 'KEY' located from 'data/mappings'. May be passed multiple times.")
+@cli.argument('-kb', '--keyboard', arg_only=True, type=keyboard_folder, completer=keyboard_completer, required=True, help='The keyboard\'s name')
+@cli.subcommand('Migrate keyboard config to "Data Driven".', hidden=True)
+def migrate(cli):
+    """Migrate keyboard configuration to "Data Driven"
+    """
+    # Merge mappings as we do not care to where "KEY" is found just that its removed
+    info_config_map = json_load(Path('data/mappings/info_config.hjson'))
+    info_rules_map = json_load(Path('data/mappings/info_rules.hjson'))
+    info_map = {**info_config_map, **info_rules_map}
+
+    # Parse target info.json which will receive updates
+    target_info = Path(find_info_json(cli.args.keyboard)[0])
+    info_data = dotty(json_load(target_info))
+
+    # Already parsed used for updates
+    kb_info_json = dotty(info_json(cli.args.keyboard))
+
+    # List of candidate files
+    files = _candidate_files(cli.args.keyboard)
+
+    # Filter down keys if requested
+    keys = list(filter(lambda key: info_map[key].get("to_json", True), info_map.keys()))
+    if cli.args.filter:
+        keys = list(set(keys) & set(cli.args.filter))
+        rejected = set(cli.args.filter) - set(keys)
+        for key in rejected:
+            cli.log.info(f'{{fg_yellow}}Skipping {key} as migration not possible...')
+
+    cli.log.info(f'{{fg_green}}Migrating keyboard {{fg_cyan}}{cli.args.keyboard}{{fg_green}}.{{fg_reset}}')
+
+    # Start migration
+    for file in files:
+        cli.log.info(f'  Migrating file {file}')
+        file_contents = file.read_text(encoding='utf-8').split('\n')
+        for key in keys:
+            for num, line in enumerate(file_contents):
+                if line.startswith(f'{key} =') or line.startswith(f'#define {key} '):
+                    cli.log.info(f'    Migrating {key}...')
+
+                    while line.rstrip().endswith('\\'):
+                        file_contents.pop(num)
+                        line = file_contents[num]
+                    file_contents.pop(num)
+
+                    update_key = info_map[key]["info_key"]
+                    if update_key in kb_info_json:
+                        info_data[update_key] = kb_info_json[update_key]
+
+        file.write_text('\n'.join(file_contents), encoding='utf-8')
+
+    # Finally write out updated info.json
+    cli.log.info(f'  Updating {target_info}')
+    target_info.write_text(json.dumps(info_data.to_dict(), cls=InfoJSONEncoder, sort_keys=True))
+
+    cli.log.info(f'{{fg_green}}Migration of keyboard {{fg_cyan}}{cli.args.keyboard}{{fg_green}} complete!{{fg_reset}}')
+    cli.log.info(f"Verify build with {{fg_yellow}}qmk compile -kb {cli.args.keyboard} -km default{{fg_reset}}.")
diff --git a/lib/python/qmk/cli/new/__init__.py b/lib/python/qmk/cli/new/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/new/__init__.py
diff --git a/lib/python/qmk/cli/new/keyboard.py b/lib/python/qmk/cli/new/keyboard.py
new file mode 100644
index 0000000000..bd02acf9c8
--- /dev/null
+++ b/lib/python/qmk/cli/new/keyboard.py
@@ -0,0 +1,273 @@
+"""This script automates the creation of new keyboard directories using a starter template.
+"""
+import re
+import json
+import shutil
+from datetime import date
+from pathlib import Path
+from dotty_dict import dotty
+
+from milc import cli
+from milc.questions import choice, question, yesno
+
+from qmk.git import git_get_username
+from qmk.json_schema import load_jsonschema
+from qmk.path import keyboard
+from qmk.json_encoders import InfoJSONEncoder
+from qmk.json_schema import deep_update
+from qmk.constants import MCU2BOOTLOADER, QMK_FIRMWARE
+
+COMMUNITY = Path('layouts/default/')
+TEMPLATE = Path('data/templates/keyboard/')
+
+# defaults
+schema = dotty(load_jsonschema('keyboard'))
+mcu_types = sorted(schema["properties.processor.enum"], key=str.casefold)
+dev_boards = sorted(schema["properties.development_board.enum"], key=str.casefold)
+available_layouts = sorted([x.name for x in COMMUNITY.iterdir() if x.is_dir()])
+
+
+def mcu_type(mcu):
+    """Callable for argparse validation.
+    """
+    if mcu not in (dev_boards + mcu_types):
+        raise ValueError
+    return mcu
+
+
+def layout_type(layout):
+    """Callable for argparse validation.
+    """
+    if layout not in available_layouts:
+        raise ValueError
+    return layout
+
+
+def keyboard_name(name):
+    """Callable for argparse validation.
+    """
+    if not validate_keyboard_name(name):
+        raise ValueError
+    return name
+
+
+def validate_keyboard_name(name):
+    """Returns True if the given keyboard name contains only lowercase a-z, 0-9 and underscore characters.
+    """
+    regex = re.compile(r'^[a-z0-9][a-z0-9/_]+$')
+    return bool(regex.match(name))
+
+
+def select_default_bootloader(mcu):
+    """Provide sane defaults for bootloader
+    """
+    return MCU2BOOTLOADER.get(mcu, "custom")
+
+
+def replace_placeholders(src, dest, tokens):
+    """Replaces the given placeholders in each template file.
+    """
+    content = src.read_text()
+    for key, value in tokens.items():
+        content = content.replace(f'%{key}%', value)
+
+    dest.write_text(content)
+
+
+def replace_string(src, token, value):
+    src.write_text(src.read_text().replace(token, value))
+
+
+def augment_community_info(config, src, dest):
+    """Splice in any additional data into info.json
+    """
+    info = json.loads(src.read_text())
+    template = json.loads(dest.read_text())
+
+    # merge community with template
+    deep_update(info, template)
+    deep_update(info, config)
+
+    # avoid assumptions on macro name by using the first available
+    first_layout = next(iter(info["layouts"].values()))["layout"]
+
+    # guess at width and height now its optional
+    width, height = (0, 0)
+    for item in first_layout:
+        width = max(width, int(item["x"]) + 1)
+        height = max(height, int(item["y"]) + 1)
+
+    info["matrix_pins"] = {
+        "cols": ["C2"] * width,
+        "rows": ["D1"] * height,
+    }
+
+    # assume a 1:1 mapping on matrix to electrical
+    for item in first_layout:
+        item["matrix"] = [int(item["y"]), int(item["x"])]
+
+    # finally write out the updated json
+    dest.write_text(json.dumps(info, cls=InfoJSONEncoder, sort_keys=True))
+
+
+def _question(*args, **kwargs):
+    """Ugly workaround until 'milc' learns to display a repromt msg
+    """
+    # TODO: Remove this once milc.questions.question handles reprompt messages
+
+    reprompt = kwargs["reprompt"]
+    del kwargs["reprompt"]
+    validate = kwargs["validate"]
+    del kwargs["validate"]
+
+    prompt = args[0]
+    ret = None
+    while not ret:
+        ret = question(prompt, **kwargs)
+        if not validate(ret):
+            ret = None
+            prompt = reprompt
+
+    return ret
+
+
+def prompt_heading_subheading(heading, subheading):
+    cli.log.info(f"{{fg_yellow}}{heading}{{style_reset_all}}")
+    cli.log.info(subheading)
+
+
+def prompt_keyboard():
+    prompt_heading_subheading("Name Your Keyboard Project", """For more information, see:
+https://docs.qmk.fm/hardware_keyboard_guidelines#naming-your-keyboard-project""")
+
+    errmsg = 'Keyboard already exists! Please choose a different name:'
+
+    return _question("Keyboard Name?", reprompt=errmsg, validate=lambda x: not keyboard(x).exists())
+
+
+def prompt_user():
+    prompt_heading_subheading("Attribution", "Used for maintainer, copyright, etc.")
+
+    return question("Your GitHub Username?", default=git_get_username())
+
+
+def prompt_name(def_name):
+    prompt_heading_subheading("More Attribution", "Used for maintainer, copyright, etc.")
+
+    return question("Your Real Name?", default=def_name)
+
+
+def prompt_layout():
+    prompt_heading_subheading("Pick Base Layout", """As a starting point, one of the common layouts can be used to
+bootstrap the process""")
+
+    # avoid overwhelming user - remove some?
+    filtered_layouts = [x for x in available_layouts if not any(xs in x for xs in ['_split', '_blocker', '_tsangan', '_f13'])]
+    filtered_layouts.append("none of the above")
+
+    return choice("Default Layout?", filtered_layouts, default=len(filtered_layouts) - 1)
+
+
+def prompt_mcu_type():
+    prompt_heading_subheading(
+        "What Powers Your Project", """Is your board using a separate development board, such as a Pro Micro,
+or is the microcontroller integrated onto the PCB?
+
+For more information, see:
+https://docs.qmk.fm/compatible_microcontrollers"""
+    )
+
+    return yesno("Using a Development Board?")
+
+
+def prompt_dev_board():
+    prompt_heading_subheading("Select Development Board", """For more information, see:
+https://docs.qmk.fm/compatible_microcontrollers""")
+
+    return choice("Development Board?", dev_boards, default=dev_boards.index("promicro"))
+
+
+def prompt_mcu():
+    prompt_heading_subheading("Select Microcontroller", """For more information, see:
+https://docs.qmk.fm/compatible_microcontrollers""")
+
+    # remove any options strictly used for compatibility
+    filtered_mcu = [x for x in mcu_types if not any(xs in x for xs in ['cortex', 'unknown'])]
+
+    return choice("Microcontroller?", filtered_mcu, default=filtered_mcu.index("atmega32u4"))
+
+
+@cli.argument('-kb', '--keyboard', help='Specify the name for the new keyboard directory', arg_only=True, type=keyboard_name)
+@cli.argument('-l', '--layout', help='Community layout to bootstrap with', arg_only=True, type=layout_type)
+@cli.argument('-t', '--type', help='Specify the keyboard MCU type (or "development_board" preset)', arg_only=True, type=mcu_type)
+@cli.argument('-u', '--username', help='Specify your username (default from Git config)', dest='name')
+@cli.argument('-n', '--realname', help='Specify your real name if you want to use that. Defaults to username', arg_only=True)
+@cli.subcommand('Creates a new keyboard directory')
+def new_keyboard(cli):
+    """Creates a new keyboard.
+    """
+    cli.log.info('{style_bright}Generating a new QMK keyboard directory{style_normal}')
+    cli.echo('')
+
+    kb_name = cli.args.keyboard if cli.args.keyboard else prompt_keyboard()
+    if not validate_keyboard_name(kb_name):
+        cli.log.error('Keyboard names must contain only {fg_cyan}lowercase a-z{fg_reset}, {fg_cyan}0-9{fg_reset}, and {fg_cyan}_{fg_reset}! Please choose a different name.')
+        return 1
+
+    if keyboard(kb_name).exists():
+        cli.log.error(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} already exists! Please choose a different name.')
+        return 1
+
+    user_name = cli.config.new_keyboard.name if cli.config.new_keyboard.name else prompt_user()
+    real_name = cli.args.realname or cli.config.new_keyboard.name if cli.args.realname or cli.config.new_keyboard.name else prompt_name(user_name)
+    default_layout = cli.args.layout if cli.args.layout else prompt_layout()
+
+    if cli.args.type:
+        mcu = cli.args.type
+    else:
+        mcu = prompt_dev_board() if prompt_mcu_type() else prompt_mcu()
+
+    config = {}
+    if mcu in dev_boards:
+        config['development_board'] = mcu
+    else:
+        config['processor'] = mcu
+        config['bootloader'] = select_default_bootloader(mcu)
+
+    detach_layout = False
+    if default_layout == 'none of the above':
+        default_layout = "ortho_4x4"
+        detach_layout = True
+
+    tokens = {  # Comment here is to force multiline formatting
+        'YEAR': str(date.today().year),
+        'KEYBOARD': kb_name,
+        'USER_NAME': user_name,
+        'REAL_NAME': real_name
+    }
+
+    # begin with making the deepest folder in the tree
+    keymaps_path = keyboard(kb_name) / 'keymaps/'
+    keymaps_path.mkdir(parents=True)
+
+    # copy in keymap.c or keymap.json
+    community_keymap = Path(COMMUNITY / f'{default_layout}/default_{default_layout}/')
+    shutil.copytree(community_keymap, keymaps_path / 'default')
+
+    # process template files
+    for file in list(TEMPLATE.iterdir()):
+        replace_placeholders(file, keyboard(kb_name) / file.name, tokens)
+
+    # merge in infos
+    community_info = Path(COMMUNITY / f'{default_layout}/info.json')
+    augment_community_info(config, community_info, keyboard(kb_name) / 'keyboard.json')
+
+    # detach community layout and rename to just "LAYOUT"
+    if detach_layout:
+        replace_string(keyboard(kb_name) / 'keyboard.json', 'LAYOUT_ortho_4x4', 'LAYOUT')
+        replace_string(keymaps_path / 'default/keymap.c', 'LAYOUT_ortho_4x4', 'LAYOUT')
+
+    cli.log.info(f'{{fg_green}}Created a new keyboard called {{fg_cyan}}{kb_name}{{fg_green}}.{{fg_reset}}')
+    cli.log.info(f"Build Command: {{fg_yellow}}qmk compile -kb {kb_name} -km default{{fg_reset}}.")
+    cli.log.info(f'Project Location: {{fg_cyan}}{QMK_FIRMWARE}/{keyboard(kb_name)}{{fg_reset}}.')
+    cli.log.info("{fg_yellow}Now update the config files to match the hardware!{fg_reset}")
diff --git a/lib/python/qmk/cli/new/keymap.py b/lib/python/qmk/cli/new/keymap.py
new file mode 100755
index 0000000000..4d19a726a4
--- /dev/null
+++ b/lib/python/qmk/cli/new/keymap.py
@@ -0,0 +1,150 @@
+"""This script automates the copying of the default keymap into your own keymap.
+"""
+import re
+import json
+import shutil
+from pathlib import Path
+
+from milc import cli
+from milc.questions import question, choice
+
+from qmk.constants import HAS_QMK_USERSPACE, QMK_USERSPACE
+from qmk.errors import NoSuchKeyboardError
+from qmk.path import is_keyboard, keymaps, keymap
+from qmk.git import git_get_username
+from qmk.decorators import automagic_keyboard, automagic_keymap
+from qmk.keyboard import keyboard_completer, keyboard_folder
+from qmk.userspace import UserspaceDefs
+from qmk.json_schema import json_load
+from qmk.json_encoders import KeymapJSONEncoder
+from qmk.info import info_json
+
+
+def _list_available_converters(kb_name):
+    """Search for converters that can be applied to a given keyboard
+    """
+    if not is_keyboard(kb_name):
+        return None
+
+    info = info_json(kb_name)
+    pin_compatible = info.get('pin_compatible')
+    if not pin_compatible:
+        return None
+
+    return sorted(folder.name.split('_to_')[-1] for folder in Path('platforms').glob(f'*/converters/{pin_compatible}_to_*'))
+
+
+def _set_converter(file, converter):
+    """add/overwrite any existing converter specified in keymap.json
+    """
+    json_data = json_load(file) if file.exists() else {}
+
+    json_data['converter'] = converter
+
+    output = json.dumps(json_data, cls=KeymapJSONEncoder, sort_keys=True)
+    file.write_text(output + '\n', encoding='utf-8')
+
+
+def validate_keymap_name(name):
+    """Returns True if the given keymap name contains only a-z, 0-9 and underscore characters.
+    """
+    regex = re.compile(r'^[a-zA-Z0-9][a-zA-Z0-9_]+$')
+    return bool(regex.match(name))
+
+
+def prompt_keyboard():
+    prompt = """{fg_yellow}Select Keyboard{style_reset_all}
+If you're unsure you can view a full list of supported keyboards with {fg_yellow}qmk list-keyboards{style_reset_all}.
+
+Keyboard Name? """
+    return question(prompt)
+
+
+def prompt_user():
+    prompt = """
+{fg_yellow}Name Your Keymap{style_reset_all}
+
+Keymap name? """
+    return question(prompt, default=git_get_username())
+
+
+def prompt_converter(kb_name):
+    prompt = """
+{fg_yellow}Configure Development Board{style_reset_all}
+For more information, see:
+https://docs.qmk.fm/feature_converters
+
+Use converter? """
+
+    converters = _list_available_converters(kb_name)
+    if not converters:
+        return None
+
+    choices = ['No (default)', *converters]
+
+    answer = choice(prompt, options=choices, default=0)
+    return None if choices.index(answer) == 0 else answer
+
+
+@cli.argument('-kb', '--keyboard', type=keyboard_folder, completer=keyboard_completer, help='Specify keyboard name. Example: 1upkeyboards/1up60hse')
+@cli.argument('-km', '--keymap', help='Specify the name for the new keymap directory')
+@cli.argument('--converter', help='Specify the name of a converter to configure')
+@cli.argument('--skip-converter', arg_only=True, action='store_true', help='Skip converter')
+@cli.subcommand('Creates a new keymap for the keyboard of your choosing')
+@automagic_keyboard
+@automagic_keymap
+def new_keymap(cli):
+    """Creates a new keymap for the keyboard of your choosing.
+    """
+    cli.log.info('{style_bright}Generating a new keymap{style_normal}')
+    cli.echo('')
+
+    # ask for user input if keyboard or keymap was not provided in the command line
+    kb_name = cli.config.new_keymap.keyboard if cli.config.new_keymap.keyboard else prompt_keyboard()
+    user_name = cli.config.new_keymap.keymap if cli.config.new_keymap.keymap else prompt_user()
+    converter = cli.config.new_keymap.converter if cli.args.skip_converter or cli.config.new_keymap.converter else prompt_converter(kb_name)
+
+    # check directories
+    try:
+        kb_name = keyboard_folder(kb_name)
+    except ValueError:
+        cli.log.error(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} does not exist! Please choose a valid name.')
+        return False
+
+    # validate before any keymap ops
+    try:
+        keymaps_dirs = keymaps(kb_name)
+        keymap_path_new = keymaps_dirs[0] / user_name
+    except NoSuchKeyboardError:
+        cli.log.error(f'Keymap folder for {{fg_cyan}}{kb_name}{{fg_reset}} does not exist!')
+        return False
+
+    keymap_path_default = keymap(kb_name, 'default')
+
+    if not keymap_path_default:
+        cli.log.error(f'Default keymap for {{fg_cyan}}{kb_name}{{fg_reset}} does not exist!')
+        return False
+
+    if not validate_keymap_name(user_name):
+        cli.log.error('Keymap names must contain only {fg_cyan}a-z{fg_reset}, {fg_cyan}0-9{fg_reset} and {fg_cyan}_{fg_reset}! Please choose a different name.')
+        return False
+
+    if keymap_path_new.exists():
+        cli.log.error(f'Keymap {{fg_cyan}}{user_name}{{fg_reset}} already exists! Please choose a different name.')
+        return False
+
+    # create user directory with default keymap files
+    shutil.copytree(keymap_path_default, keymap_path_new, symlinks=True)
+
+    if converter:
+        _set_converter(keymap_path_new / 'keymap.json', converter)
+
+    # end message to user
+    cli.log.info(f'{{fg_green}}Created a new keymap called {{fg_cyan}}{user_name}{{fg_green}} in: {{fg_cyan}}{keymap_path_new}{{fg_reset}}.')
+    cli.log.info(f"Compile a firmware with your new keymap by typing: {{fg_yellow}}qmk compile -kb {kb_name} -km {user_name}{{fg_reset}}.")
+
+    # Add to userspace compile if we have userspace available
+    if HAS_QMK_USERSPACE:
+        userspace = UserspaceDefs(QMK_USERSPACE / 'qmk.json')
+        userspace.add_target(keyboard=kb_name, keymap=user_name, do_print=False)
+        return userspace.save()
diff --git a/lib/python/qmk/cli/painter/__init__.py b/lib/python/qmk/cli/painter/__init__.py
new file mode 100644
index 0000000000..d1a225346c
--- /dev/null
+++ b/lib/python/qmk/cli/painter/__init__.py
@@ -0,0 +1,2 @@
+from . import convert_graphics
+from . import make_font
diff --git a/lib/python/qmk/cli/painter/convert_graphics.py b/lib/python/qmk/cli/painter/convert_graphics.py
new file mode 100644
index 0000000000..f74d655fd5
--- /dev/null
+++ b/lib/python/qmk/cli/painter/convert_graphics.py
@@ -0,0 +1,77 @@
+"""This script tests QGF functionality.
+"""
+from io import BytesIO
+from qmk.path import normpath
+from qmk.painter import generate_subs, render_header, render_source, valid_formats
+from milc import cli
+from PIL import Image
+
+
+@cli.argument('-v', '--verbose', arg_only=True, action='store_true', help='Turns on verbose output.')
+@cli.argument('-i', '--input', required=True, help='Specify input graphic file.')
+@cli.argument('-o', '--output', default='', help='Specify output directory. Defaults to same directory as input.')
+@cli.argument('-f', '--format', required=True, help=f'Output format, valid types: {", ".join(valid_formats.keys())}')
+@cli.argument('-r', '--no-rle', arg_only=True, action='store_true', help='Disables the use of RLE when encoding images.')
+@cli.argument('-d', '--no-deltas', arg_only=True, action='store_true', help='Disables the use of delta frames when encoding animations.')
+@cli.argument('-w', '--raw', arg_only=True, action='store_true', help='Writes out the QGF file as raw data instead of c/h combo.')
+@cli.subcommand('Converts an input image to something QMK understands')
+def painter_convert_graphics(cli):
+    """Converts an image file to a format that Quantum Painter understands.
+
+    This command uses the `qmk.painter` module to generate a Quantum Painter image defintion from an image. The generated definitions are written to a files next to the input -- `INPUT.c` and `INPUT.h`.
+    """
+    # Work out the input file
+    if cli.args.input != '-':
+        cli.args.input = normpath(cli.args.input)
+
+        # Error checking
+        if not cli.args.input.exists():
+            cli.log.error('Input image file does not exist!')
+            cli.print_usage()
+            return False
+
+    # Work out the output directory
+    if len(cli.args.output) == 0:
+        cli.args.output = cli.args.input.parent
+    cli.args.output = normpath(cli.args.output)
+
+    # Ensure we have a valid format
+    if cli.args.format not in valid_formats.keys():
+        cli.log.error('Output format %s is invalid. Allowed values: %s' % (cli.args.format, ', '.join(valid_formats.keys())))
+        cli.print_usage()
+        return False
+
+    # Work out the encoding parameters
+    format = valid_formats[cli.args.format]
+
+    # Load the input image
+    input_img = Image.open(cli.args.input)
+
+    # Convert the image to QGF using PIL
+    out_data = BytesIO()
+    metadata = []
+    input_img.save(out_data, "QGF", use_deltas=(not cli.args.no_deltas), use_rle=(not cli.args.no_rle), qmk_format=format, verbose=cli.args.verbose, metadata=metadata)
+    out_bytes = out_data.getvalue()
+
+    if cli.args.raw:
+        raw_file = cli.args.output / f"{cli.args.input.stem}.qgf"
+        with open(raw_file, 'wb') as raw:
+            raw.write(out_bytes)
+        return
+
+    # Work out the text substitutions for rendering the output data
+    subs = generate_subs(cli, out_bytes, image_metadata=metadata, command_name="painter_convert_graphics")
+
+    # Render and write the header file
+    header_text = render_header(subs)
+    header_file = cli.args.output / f"{cli.args.input.stem}.qgf.h"
+    with open(header_file, 'w') as header:
+        print(f"Writing {header_file}...")
+        header.write(header_text)
+
+    # Render and write the source file
+    source_text = render_source(subs)
+    source_file = cli.args.output / f"{cli.args.input.stem}.qgf.c"
+    with open(source_file, 'w') as source:
+        print(f"Writing {source_file}...")
+        source.write(source_text)
diff --git a/lib/python/qmk/cli/painter/make_font.py b/lib/python/qmk/cli/painter/make_font.py
new file mode 100644
index 0000000000..3e18fd74a5
--- /dev/null
+++ b/lib/python/qmk/cli/painter/make_font.py
@@ -0,0 +1,79 @@
+"""This script automates the conversion of font files into a format QMK firmware understands.
+"""
+
+from io import BytesIO
+from qmk.path import normpath
+from qmk.painter_qff import _generate_font_glyphs_list, QFFFont
+from qmk.painter import generate_subs, render_header, render_source, valid_formats
+from milc import cli
+
+
+@cli.argument('-f', '--font', required=True, help='Specify input font file.')
+@cli.argument('-o', '--output', required=True, help='Specify output image path.')
+@cli.argument('-s', '--size', default=12, help='Specify font size. Default 12.')
+@cli.argument('-n', '--no-ascii', arg_only=True, action='store_true', help='Disables output of the full ASCII character set (0x20..0x7E), exporting only the glyphs specified.')
+@cli.argument('-u', '--unicode-glyphs', default='', help='Also generate the specified unicode glyphs.')
+@cli.argument('-a', '--no-aa', arg_only=True, action='store_true', help='Disable anti-aliasing on fonts.')
+@cli.subcommand('Converts an input font to something QMK understands')
+def painter_make_font_image(cli):
+    # Create the font object
+    font = QFFFont(cli)
+    # Read from the input file
+    cli.args.font = normpath(cli.args.font)
+    font.generate_image(cli.args.font, cli.args.size, include_ascii_glyphs=(not cli.args.no_ascii), unicode_glyphs=cli.args.unicode_glyphs, use_aa=(False if cli.args.no_aa else True))
+    # Render out the data
+    font.save_to_image(normpath(cli.args.output))
+
+
+@cli.argument('-i', '--input', help='Specify input graphic file.')
+@cli.argument('-o', '--output', default='', help='Specify output directory. Defaults to same directory as input.')
+@cli.argument('-n', '--no-ascii', arg_only=True, action='store_true', help='Disables output of the full ASCII character set (0x20..0x7E), exporting only the glyphs specified.')
+@cli.argument('-u', '--unicode-glyphs', default='', help='Also generate the specified unicode glyphs.')
+@cli.argument('-f', '--format', required=True, help=f'Output format, valid types: {", ".join(valid_formats.keys())}')
+@cli.argument('-r', '--no-rle', arg_only=True, action='store_true', help='Disable the use of RLE to minimise converted image size.')
+@cli.argument('-w', '--raw', arg_only=True, action='store_true', help='Writes out the QFF file as raw data instead of c/h combo.')
+@cli.subcommand('Converts an input font image to something QMK firmware understands')
+def painter_convert_font_image(cli):
+    # Work out the format
+    format = valid_formats[cli.args.format]
+
+    # Create the font object
+    font = QFFFont(cli.log)
+
+    # Read from the input file
+    cli.args.input = normpath(cli.args.input)
+    font.read_from_image(cli.args.input, include_ascii_glyphs=(not cli.args.no_ascii), unicode_glyphs=cli.args.unicode_glyphs)
+
+    # Work out the output directory
+    if len(cli.args.output) == 0:
+        cli.args.output = cli.args.input.parent
+    cli.args.output = normpath(cli.args.output)
+
+    # Render out the data
+    out_data = BytesIO()
+    font.save_to_qff(format, not cli.args.no_rle, out_data)
+    out_bytes = out_data.getvalue()
+
+    if cli.args.raw:
+        raw_file = cli.args.output / f"{cli.args.input.stem}.qff"
+        with open(raw_file, 'wb') as raw:
+            raw.write(out_bytes)
+        return
+
+    # Work out the text substitutions for rendering the output data
+    metadata = {"glyphs": _generate_font_glyphs_list(not cli.args.no_ascii, cli.args.unicode_glyphs)}
+    subs = generate_subs(cli, out_bytes, font_metadata=metadata, command_name="painter_convert_font_image")
+
+    # Render and write the header file
+    header_text = render_header(subs)
+    header_file = cli.args.output / f"{cli.args.input.stem}.qff.h"
+    with open(header_file, 'w') as header:
+        print(f"Writing {header_file}...")
+        header.write(header_text)
+
+    # Render and write the source file
+    source_text = render_source(subs)
+    source_file = cli.args.output / f"{cli.args.input.stem}.qff.c"
+    with open(source_file, 'w') as source:
+        print(f"Writing {source_file}...")
+        source.write(source_text)
diff --git a/lib/python/qmk/cli/pytest.py b/lib/python/qmk/cli/pytest.py
new file mode 100644
index 0000000000..5c9c173caa
--- /dev/null
+++ b/lib/python/qmk/cli/pytest.py
@@ -0,0 +1,18 @@
+"""QMK Python Unit Tests
+
+QMK script to run unit and integration tests against our python code.
+"""
+from subprocess import DEVNULL
+
+from milc import cli
+
+
+@cli.argument('-t', '--test', arg_only=True, action='append', default=[], help="Mapped to nose2 'testNames' positional argument - https://docs.nose2.io/en/latest/usage.html#specifying-tests-to-run")
+@cli.subcommand('QMK Python Unit Tests', hidden=False if cli.config.user.developer else True)
+def pytest(cli):
+    """Run several linting/testing commands.
+    """
+    nose2 = cli.run(['nose2', '-v', '-t', 'lib/python', *cli.args.test], capture_output=False, stdin=DEVNULL)
+    flake8 = cli.run(['flake8', 'lib/python'], capture_output=False, stdin=DEVNULL)
+
+    return flake8.returncode | nose2.returncode
diff --git a/lib/python/qmk/cli/resolve_alias.py b/lib/python/qmk/cli/resolve_alias.py
new file mode 100644
index 0000000000..dff2242b28
--- /dev/null
+++ b/lib/python/qmk/cli/resolve_alias.py
@@ -0,0 +1,16 @@
+from qmk.keyboard import keyboard_folder
+
+from milc import cli
+
+
+@cli.argument('--allow-unknown', arg_only=True, action='store_true', help="Return original if rule is not a valid keyboard.")
+@cli.argument('keyboard', arg_only=True, help='The keyboard\'s name')
+@cli.subcommand('Resolve any keyboard_aliases for provided rule')
+def resolve_alias(cli):
+    try:
+        print(keyboard_folder(cli.args.keyboard))
+    except ValueError:
+        if cli.args.allow_unknown:
+            print(cli.args.keyboard)
+        else:
+            raise
diff --git a/lib/python/qmk/cli/test/__init__.py b/lib/python/qmk/cli/test/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/cli/test/__init__.py
diff --git a/lib/python/qmk/cli/test/c.py b/lib/python/qmk/cli/test/c.py
new file mode 100644
index 0000000000..7a4e20d5e6
--- /dev/null
+++ b/lib/python/qmk/cli/test/c.py
@@ -0,0 +1,47 @@
+import fnmatch
+import re
+from subprocess import DEVNULL
+
+from milc import cli
+
+from qmk.commands import find_make, get_make_parallel_args, build_environment
+
+
+@cli.argument('-j', '--parallel', type=int, default=1, help="Set the number of parallel make jobs; 0 means unlimited.")
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.")
+@cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.")
+@cli.argument('-l', '--list', arg_only=True, action='store_true', help='List available tests.')
+@cli.argument('-t', '--test', arg_only=True, action='append', default=[], help="Test to run from the available list. Supports wildcard globs. May be passed multiple times.")
+@cli.subcommand("QMK C Unit Tests.", hidden=False if cli.config.user.developer else True)
+def test_c(cli):
+    """Run native unit tests.
+    """
+    list_tests = cli.run([find_make(), 'list-tests', 'SILENT=true'])
+    available_tests = sorted(list_tests.stdout.strip().split())
+
+    if cli.args.list:
+        return print("\n".join(available_tests))
+
+    # expand any wildcards
+    filtered_tests = set()
+    for test in cli.args.test:
+        regex = re.compile(fnmatch.translate(test))
+        filtered_tests |= set(filter(regex.match, available_tests))
+
+    for invalid in filtered_tests - set(available_tests):
+        cli.log.warning(f'Invalid test provided: {invalid}')
+
+    # convert test names to build targets
+    targets = list(map(lambda x: f'test:{x}', filtered_tests or ['all']))
+
+    if cli.args.clean:
+        targets.insert(0, 'clean')
+
+    # Add in the environment vars
+    for key, value in build_environment(cli.args.env).items():
+        targets.append(f'{key}={value}')
+
+    command = [find_make(), *get_make_parallel_args(cli.config.test_c.parallel), *targets]
+
+    cli.log.info('Compiling tests with {fg_cyan}%s', ' '.join(command))
+    return cli.run(command, capture_output=False, stdin=DEVNULL).returncode
diff --git a/lib/python/qmk/cli/userspace/__init__.py b/lib/python/qmk/cli/userspace/__init__.py
new file mode 100644
index 0000000000..5757d3a4c9
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/__init__.py
@@ -0,0 +1,5 @@
+from . import doctor
+from . import add
+from . import remove
+from . import list
+from . import compile
diff --git a/lib/python/qmk/cli/userspace/add.py b/lib/python/qmk/cli/userspace/add.py
new file mode 100644
index 0000000000..eea70efb95
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/add.py
@@ -0,0 +1,56 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from pathlib import Path
+from milc import cli
+
+from qmk.commands import parse_env_vars
+from qmk.constants import QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.keyboard import keyboard_completer, keyboard_folder_or_all
+from qmk.keymap import keymap_completer, is_keymap_target
+from qmk.userspace import UserspaceDefs
+
+
+@cli.argument('builds', nargs='*', arg_only=True, help="List of builds in form <keyboard>:<keymap>, or path to a keymap JSON file.")
+@cli.argument('-kb', '--keyboard', type=keyboard_folder_or_all, completer=keyboard_completer, help='The keyboard to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Extra variables to set during build. May be passed multiple times.")
+@cli.subcommand('Adds a build target to userspace `qmk.json`.')
+def userspace_add(cli):
+    if not HAS_QMK_USERSPACE:
+        cli.log.error('Could not determine QMK userspace location. Please run `qmk doctor` or `qmk userspace-doctor` to diagnose.')
+        return False
+
+    build_env = None if len(cli.args.env) == 0 else parse_env_vars(cli.args.env)
+
+    userspace = UserspaceDefs(QMK_USERSPACE / 'qmk.json')
+
+    if len(cli.args.builds) > 0:
+        json_like_targets = list([Path(p) for p in filter(lambda e: Path(e).exists() and Path(e).suffix == '.json', cli.args.builds)])
+        make_like_targets = list(filter(lambda e: Path(e) not in json_like_targets, cli.args.builds))
+
+        for e in json_like_targets:
+            userspace.add_target(json_path=e)
+
+        for e in make_like_targets:
+            s = e.split(':')
+            userspace.add_target(keyboard=s[0], keymap=s[1])
+
+    else:
+        failed = False
+        try:
+            if not is_keymap_target(cli.args.keyboard, cli.args.keymap):
+                failed = True
+        except KeyError:
+            failed = True
+
+        if failed:
+            from qmk.cli.new.keymap import new_keymap
+            cli.config.new_keymap.keyboard = cli.args.keyboard
+            cli.config.new_keymap.keymap = cli.args.keymap
+            cli.args.skip_converter = True
+            if new_keymap(cli) is not False:
+                userspace.add_target(keyboard=cli.args.keyboard, keymap=cli.args.keymap, build_env=build_env)
+        else:
+            userspace.add_target(keyboard=cli.args.keyboard, keymap=cli.args.keymap, build_env=build_env)
+
+    return userspace.save()
diff --git a/lib/python/qmk/cli/userspace/compile.py b/lib/python/qmk/cli/userspace/compile.py
new file mode 100644
index 0000000000..64fa3ed0c9
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/compile.py
@@ -0,0 +1,46 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from pathlib import Path
+from milc import cli
+
+from qmk.constants import QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.commands import build_environment
+from qmk.userspace import UserspaceDefs
+from qmk.build_targets import JsonKeymapBuildTarget
+from qmk.search import search_keymap_targets
+from qmk.cli.mass_compile import mass_compile_targets
+from qmk.util import maybe_exit_config
+
+
+def _extra_arg_setter(target, extra_args):
+    target.extra_args = extra_args
+
+
+@cli.argument('-t', '--no-temp', arg_only=True, action='store_true', help="Remove temporary files during build.")
+@cli.argument('-j', '--parallel', type=int, default=1, help="Set the number of parallel make jobs; 0 means unlimited.")
+@cli.argument('-c', '--clean', arg_only=True, action='store_true', help="Remove object files before compiling.")
+@cli.argument('-n', '--dry-run', arg_only=True, action='store_true', help="Don't actually build, just show the commands to be run.")
+@cli.argument('-p', '--print-failures', arg_only=True, action='store_true', help="Print failed builds.")
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Set a variable to be passed to make. May be passed multiple times.")
+@cli.subcommand('Compiles the build targets specified in userspace `qmk.json`.')
+def userspace_compile(cli):
+    if not HAS_QMK_USERSPACE:
+        cli.log.error('Could not determine QMK userspace location. Please run `qmk doctor` or `qmk userspace-doctor` to diagnose.')
+        return False
+
+    maybe_exit_config(should_exit=False, should_reraise=True)
+
+    userspace = UserspaceDefs(QMK_USERSPACE / 'qmk.json')
+
+    build_targets = []
+    keyboard_keymap_targets = []
+    for e in userspace.build_targets:
+        if isinstance(e, Path):
+            build_targets.append(JsonKeymapBuildTarget(e))
+        elif isinstance(e, dict):
+            f = e['env'] if 'env' in e else None
+            keyboard_keymap_targets.append((e['keyboard'], e['keymap'], f))
+    if len(keyboard_keymap_targets) > 0:
+        build_targets.extend(search_keymap_targets(keyboard_keymap_targets))
+
+    return mass_compile_targets(list(set(build_targets)), cli.args.clean, cli.args.dry_run, cli.config.userspace_compile.no_temp, cli.config.userspace_compile.parallel, cli.args.print_failures, **build_environment(cli.args.env))
diff --git a/lib/python/qmk/cli/userspace/doctor.py b/lib/python/qmk/cli/userspace/doctor.py
new file mode 100644
index 0000000000..7c016e5a2f
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/doctor.py
@@ -0,0 +1,13 @@
+# Copyright 2023 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from milc import cli
+
+from qmk.constants import QMK_FIRMWARE, HAS_QMK_USERSPACE
+from qmk.cli.doctor.main import userspace_tests
+
+
+@cli.subcommand('Checks userspace configuration.')
+def userspace_doctor(cli):
+    userspace_tests(QMK_FIRMWARE)
+
+    return 0 if HAS_QMK_USERSPACE else 1
diff --git a/lib/python/qmk/cli/userspace/list.py b/lib/python/qmk/cli/userspace/list.py
new file mode 100644
index 0000000000..e902483b6b
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/list.py
@@ -0,0 +1,69 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from pathlib import Path
+from dotty_dict import Dotty
+from milc import cli
+
+from qmk.constants import QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.userspace import UserspaceDefs
+from qmk.build_targets import BuildTarget
+from qmk.keyboard import is_all_keyboards, keyboard_folder
+from qmk.keymap import is_keymap_target
+from qmk.search import search_keymap_targets
+from qmk.util import maybe_exit_config
+
+
+def _extra_arg_setter(target, extra_args):
+    target.extra_args = extra_args
+
+
+@cli.argument('-e', '--expand', arg_only=True, action='store_true', help="Expands any use of `all` for either keyboard or keymap.")
+@cli.subcommand('Lists the build targets specified in userspace `qmk.json`.')
+def userspace_list(cli):
+    if not HAS_QMK_USERSPACE:
+        cli.log.error('Could not determine QMK userspace location. Please run `qmk doctor` or `qmk userspace-doctor` to diagnose.')
+        return False
+
+    maybe_exit_config(should_exit=False, should_reraise=True)
+
+    userspace = UserspaceDefs(QMK_USERSPACE / 'qmk.json')
+
+    if cli.args.expand:
+        build_targets = []
+        keyboard_keymap_targets = []
+        for e in userspace.build_targets:
+            if isinstance(e, Path):
+                build_targets.append(e)
+            elif isinstance(e, dict) or isinstance(e, Dotty):
+                f = e['env'] if 'env' in e else None
+                keyboard_keymap_targets.append((e['keyboard'], e['keymap'], f))
+        if len(keyboard_keymap_targets) > 0:
+            build_targets.extend(search_keymap_targets(keyboard_keymap_targets))
+    else:
+        build_targets = userspace.build_targets
+
+    for e in build_targets:
+        if isinstance(e, Path):
+            # JSON keymap from userspace
+            cli.log.info(f'JSON keymap: {{fg_cyan}}{e}{{fg_reset}}')
+            continue
+        elif isinstance(e, dict) or isinstance(e, Dotty):
+            # keyboard/keymap dict from userspace
+            keyboard = e['keyboard']
+            keymap = e['keymap']
+            extra_args = e.get('env')
+        elif isinstance(e, BuildTarget):
+            # BuildTarget from search_keymap_targets()
+            keyboard = e.keyboard
+            keymap = e.keymap
+            extra_args = e.extra_args
+
+        extra_args_str = ''
+        if extra_args is not None and len(extra_args) > 0:
+            extra_args_str = ', '.join([f'{{fg_cyan}}{k}={v}{{fg_reset}}' for k, v in extra_args.items()])
+            extra_args_str = f' ({{fg_cyan}}{extra_args_str}{{fg_reset}})'
+
+        if is_all_keyboards(keyboard) or is_keymap_target(keyboard_folder(keyboard), keymap):
+            cli.log.info(f'Keyboard: {{fg_cyan}}{keyboard}{{fg_reset}}, keymap: {{fg_cyan}}{keymap}{{fg_reset}}{extra_args_str}')
+        else:
+            cli.log.warning(f'Keyboard: {{fg_cyan}}{keyboard}{{fg_reset}}, keymap: {{fg_cyan}}{keymap}{{fg_reset}}{extra_args_str} -- not found!')
diff --git a/lib/python/qmk/cli/userspace/path.py b/lib/python/qmk/cli/userspace/path.py
new file mode 100755
index 0000000000..d0c1b544fb
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/path.py
@@ -0,0 +1,8 @@
+from milc import cli
+from qmk.constants import QMK_USERSPACE
+
+
+@cli.subcommand('Detected path to QMK Userspace.', hidden=True)
+def userspace_path(cli):
+    print(QMK_USERSPACE or '')
+    return
diff --git a/lib/python/qmk/cli/userspace/remove.py b/lib/python/qmk/cli/userspace/remove.py
new file mode 100644
index 0000000000..b2da08a98e
--- /dev/null
+++ b/lib/python/qmk/cli/userspace/remove.py
@@ -0,0 +1,41 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from pathlib import Path
+from milc import cli
+
+from qmk.commands import parse_env_vars
+from qmk.constants import QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.keyboard import keyboard_completer, keyboard_folder_or_all
+from qmk.keymap import keymap_completer
+from qmk.userspace import UserspaceDefs
+
+
+@cli.argument('builds', nargs='*', arg_only=True, help="List of builds in form <keyboard>:<keymap>, or path to a keymap JSON file.")
+@cli.argument('-kb', '--keyboard', type=keyboard_folder_or_all, completer=keyboard_completer, help='The keyboard to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-km', '--keymap', completer=keymap_completer, help='The keymap to build a firmware for. Ignored when a configurator export is supplied.')
+@cli.argument('-e', '--env', arg_only=True, action='append', default=[], help="Extra variables to set during build. May be passed multiple times.")
+@cli.subcommand('Removes a build target from userspace `qmk.json`.')
+def userspace_remove(cli):
+    if not HAS_QMK_USERSPACE:
+        cli.log.error('Could not determine QMK userspace location. Please run `qmk doctor` or `qmk userspace-doctor` to diagnose.')
+        return False
+
+    build_env = None if len(cli.args.env) == 0 else parse_env_vars(cli.args.env)
+
+    userspace = UserspaceDefs(QMK_USERSPACE / 'qmk.json')
+
+    if len(cli.args.builds) > 0:
+        json_like_targets = list([Path(p) for p in filter(lambda e: Path(e).exists() and Path(e).suffix == '.json', cli.args.builds)])
+        make_like_targets = list(filter(lambda e: Path(e) not in json_like_targets, cli.args.builds))
+
+        for e in json_like_targets:
+            userspace.remove_target(json_path=e)
+
+        for e in make_like_targets:
+            s = e.split(':')
+            userspace.remove_target(keyboard=s[0], keymap=s[1], build_env=build_env)
+
+    else:
+        userspace.remove_target(keyboard=cli.args.keyboard, keymap=cli.args.keymap, build_env=build_env)
+
+    return userspace.save()
diff --git a/lib/python/qmk/cli/via2json.py b/lib/python/qmk/cli/via2json.py
new file mode 100755
index 0000000000..0997e9ca9f
--- /dev/null
+++ b/lib/python/qmk/cli/via2json.py
@@ -0,0 +1,159 @@
+"""Generate a keymap.c from a configurator export.
+"""
+import json
+import re
+
+from milc import cli
+
+import qmk.keyboard
+import qmk.path
+from qmk.info import info_json
+from qmk.json_encoders import KeymapJSONEncoder
+from qmk.commands import dump_lines
+from qmk.keymap import generate_json
+
+
+def _find_via_layout_macro(keyboard_data):
+    """Assume layout macro when only 1 is available
+    """
+    layouts = list(keyboard_data['layouts'].keys())
+    return layouts[0] if len(layouts) == 1 else None
+
+
+def _convert_macros(via_macros):
+    via_macros = list(filter(lambda f: bool(f), via_macros))
+    if len(via_macros) == 0:
+        return list()
+    split_regex = re.compile(r'(}\,)|(\,{)')
+    macro_group_regex = re.compile(r'({.+?})')
+    macros = list()
+    for via_macro in via_macros:
+        # Split VIA macro to its elements
+        macro = split_regex.split(via_macro)
+        # Remove junk elements (None, '},' and ',{')
+        macro = list(filter(lambda f: False if f in (None, '},', ',{') else True, macro))
+        macro_data = list()
+        for m in macro:
+            if '{' in m or '}' in m:
+                # Split macro groups
+                macro_groups = macro_group_regex.findall(m)
+                for macro_group in macro_groups:
+                    # Remove whitespaces and curly braces from around group
+                    macro_group = macro_group.strip(' {}')
+
+                    macro_action = 'tap'
+                    macro_keycodes = []
+
+                    if macro_group[0] == '+':
+                        macro_action = 'down'
+                        macro_keycodes.append(macro_group[1:])
+                    elif macro_group[0] == '-':
+                        macro_action = 'up'
+                        macro_keycodes.append(macro_group[1:])
+                    else:
+                        macro_keycodes.extend(macro_group.split(',') if ',' in macro_group else [macro_group])
+
+                    # Remove the KC prefixes
+                    macro_keycodes = list(map(lambda s: s.replace('KC_', ''), macro_keycodes))
+
+                    macro_data.append({"action": macro_action, "keycodes": macro_keycodes})
+            else:
+                # Found text
+                macro_data.append(m)
+        macros.append(macro_data)
+
+    return macros
+
+
+def _fix_macro_keys(keymap_data):
+    macro_no = re.compile(r'MACRO0?\(([0-9]{1,2})\)')
+    for i in range(0, len(keymap_data)):
+        for j in range(0, len(keymap_data[i])):
+            kc = keymap_data[i][j]
+            m = macro_no.match(kc)
+            if m:
+                keymap_data[i][j] = f'MC_{m.group(1)}'
+    return keymap_data
+
+
+def _via_to_keymap(via_backup, keyboard_data, keymap_layout):
+    # Check if passed LAYOUT is correct
+    layout_data = keyboard_data['layouts'].get(keymap_layout)
+    if not layout_data:
+        cli.log.error(f'LAYOUT macro {keymap_layout} is not a valid one for keyboard {cli.args.keyboard}!')
+        return None
+
+    layout_data = layout_data['layout']
+    sorting_hat = list()
+    for index, data in enumerate(layout_data):
+        sorting_hat.append([index, data['matrix']])
+
+    sorting_hat.sort(key=lambda k: (k[1][0], k[1][1]))
+
+    pos = 0
+    for row_num in range(0, keyboard_data['matrix_size']['rows']):
+        for col_num in range(0, keyboard_data['matrix_size']['cols']):
+            if pos >= len(sorting_hat) or sorting_hat[pos][1][0] != row_num or sorting_hat[pos][1][1] != col_num:
+                sorting_hat.insert(pos, [None, [row_num, col_num]])
+            else:
+                sorting_hat.append([None, [row_num, col_num]])
+            pos += 1
+
+    keymap_data = list()
+    for layer in via_backup['layers']:
+        pos = 0
+        layer_data = list()
+        for key in layer:
+            if sorting_hat[pos][0] is not None:
+                layer_data.append([sorting_hat[pos][0], key])
+            pos += 1
+        layer_data.sort()
+        layer_data = [kc[1] for kc in layer_data]
+        keymap_data.append(layer_data)
+
+    return keymap_data
+
+
+@cli.argument('-o', '--output', arg_only=True, type=qmk.path.normpath, help='File to write to')
+@cli.argument('-q', '--quiet', arg_only=True, action='store_true', help="Quiet mode, only output error messages")
+@cli.argument('filename', type=qmk.path.FileType('r'), arg_only=True, help='VIA Backup JSON file')
+@cli.argument('-kb', '--keyboard', type=qmk.keyboard.keyboard_folder, completer=qmk.keyboard.keyboard_completer, arg_only=True, required=True, help='The keyboard\'s name')
+@cli.argument('-km', '--keymap', arg_only=True, default='via2json', help='The keymap\'s name')
+@cli.argument('-l', '--layout', arg_only=True, help='The keymap\'s layout')
+@cli.subcommand('Convert a VIA backup json to keymap.json format.')
+def via2json(cli):
+    """Convert a VIA backup json to keymap.json format.
+
+    This command uses the `qmk.keymap` module to generate a keymap.json from a VIA backup json. The generated keymap is written to stdout, or to a file if -o is provided.
+    """
+    # Load the VIA backup json
+    with cli.args.filename.open('r') as fd:
+        via_backup = json.load(fd)
+
+    keyboard_data = info_json(cli.args.keyboard)
+
+    # Find appropriate layout macro
+    keymap_layout = cli.args.layout if cli.args.layout else _find_via_layout_macro(keyboard_data)
+    if not keymap_layout:
+        cli.log.error(f"Couldn't find LAYOUT macro for keyboard {cli.args.keyboard}. Please specify it with the '-l' argument.")
+        return False
+
+    # Get keycode array
+    keymap_data = _via_to_keymap(via_backup, keyboard_data, keymap_layout)
+    if not keymap_data:
+        cli.log.error(f'Could not extract valid keycode data from VIA backup matching keyboard {cli.args.keyboard}!')
+        return False
+
+    # Convert macros
+    macro_data = list()
+    if via_backup.get('macros'):
+        macro_data = _convert_macros(via_backup['macros'])
+
+        # Replace VIA macro keys with JSON keymap ones
+        keymap_data = _fix_macro_keys(keymap_data)
+
+    # Generate the keymap.json
+    keymap_json = generate_json(cli.args.keymap, cli.args.keyboard, keymap_layout, keymap_data, macro_data)
+
+    keymap_lines = [json.dumps(keymap_json, cls=KeymapJSONEncoder, sort_keys=True)]
+    dump_lines(cli.args.output, keymap_lines, cli.args.quiet)
diff --git a/lib/python/qmk/commands.py b/lib/python/qmk/commands.py
new file mode 100644
index 0000000000..ac1455967d
--- /dev/null
+++ b/lib/python/qmk/commands.py
@@ -0,0 +1,127 @@
+"""Helper functions for commands.
+"""
+import os
+import sys
+import shutil
+from pathlib import Path
+
+from milc import cli
+import jsonschema
+
+from qmk.constants import QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.json_schema import json_load, validate
+from qmk.keyboard import keyboard_alias_definitions
+from qmk.util import maybe_exit
+from qmk.path import unix_style_path
+
+
+def find_make():
+    """Returns the correct make command for this environment.
+    """
+    make_cmd = os.environ.get('MAKE')
+
+    if not make_cmd:
+        make_cmd = 'gmake' if shutil.which('gmake') else 'make'
+
+    return make_cmd
+
+
+def get_make_parallel_args(parallel=1):
+    """Returns the arguments for running the specified number of parallel jobs.
+    """
+    parallel_args = []
+
+    if int(parallel) <= 0:
+        # 0 or -1 means -j without argument (unlimited jobs)
+        parallel_args.append('--jobs')
+    elif int(parallel) > 1:
+        parallel_args.append('--jobs=' + str(parallel))
+
+    if int(parallel) != 1:
+        # If more than 1 job is used, synchronize parallel output by target
+        parallel_args.append('--output-sync=target')
+
+    return parallel_args
+
+
+def parse_configurator_json(configurator_file):
+    """Open and parse a configurator json export
+    """
+    user_keymap = json_load(configurator_file)
+    # Validate against the jsonschema
+    try:
+        validate(user_keymap, 'qmk.keymap.v1')
+
+    except jsonschema.ValidationError as e:
+        cli.log.error(f'Invalid JSON keymap: {configurator_file} : {e.message}')
+        maybe_exit(1)
+
+    keyboard = user_keymap.get('keyboard', None)
+    aliases = keyboard_alias_definitions()
+
+    while keyboard in aliases:
+        last_keyboard = keyboard
+        keyboard = aliases[keyboard].get('target', keyboard)
+        if keyboard == last_keyboard:
+            break
+
+    user_keymap['keyboard'] = keyboard
+    return user_keymap
+
+
+def parse_env_vars(args):
+    """Common processing for cli.args.env
+    """
+    envs = {}
+    for env in args:
+        if '=' in env:
+            key, value = env.split('=', 1)
+            envs[key] = value
+        else:
+            cli.log.warning('Invalid environment variable: %s', env)
+    return envs
+
+
+def build_environment(args):
+    envs = parse_env_vars(args)
+
+    if HAS_QMK_USERSPACE:
+        envs['QMK_USERSPACE'] = unix_style_path(Path(QMK_USERSPACE).resolve())
+
+    return envs
+
+
+def in_virtualenv():
+    """Check if running inside a virtualenv.
+    Based on https://stackoverflow.com/a/1883251
+    """
+    active_prefix = getattr(sys, "base_prefix", None) or getattr(sys, "real_prefix", None) or sys.prefix
+    return active_prefix != sys.prefix
+
+
+def dump_lines(output_file, lines, quiet=True, remove_repeated_newlines=False):
+    """Handle dumping to stdout or file
+    Creates parent folders if required
+    """
+    generated = '\n'.join(lines) + '\n'
+    if remove_repeated_newlines:
+        while '\n\n\n' in generated:
+            generated = generated.replace('\n\n\n', '\n\n')
+    if output_file and output_file.name != '-':
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        if output_file.exists():
+            with open(output_file, 'r', encoding='utf-8', newline='\n') as f:
+                existing = f.read()
+            if existing == generated:
+                if not quiet:
+                    cli.log.info(f'No changes to {output_file.name}.')
+                return
+            output_file.replace(output_file.parent / (output_file.name + '.bak'))
+        with open(output_file, 'w', encoding='utf-8', newline='\n') as f:
+            f.write(generated)
+        # output_file.write_text(generated, encoding='utf-8', newline='\n') # `newline` needs Python 3.10
+
+        if not quiet:
+            cli.log.info(f'Wrote {output_file.name} to {output_file}.')
+    else:
+        print(generated)
diff --git a/lib/python/qmk/comment_remover.py b/lib/python/qmk/comment_remover.py
new file mode 100644
index 0000000000..45a25257f8
--- /dev/null
+++ b/lib/python/qmk/comment_remover.py
@@ -0,0 +1,20 @@
+"""Removes C/C++ style comments from text.
+
+Gratefully adapted from https://stackoverflow.com/a/241506
+"""
+import re
+
+comment_pattern = re.compile(r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', re.DOTALL | re.MULTILINE)
+
+
+def _comment_stripper(match):
+    """Removes C/C++ style comments from a regex match.
+    """
+    s = match.group(0)
+    return ' ' if s.startswith('/') else s
+
+
+def comment_remover(text):
+    """Remove C/C++ style comments from text.
+    """
+    return re.sub(comment_pattern, _comment_stripper, text)
diff --git a/lib/python/qmk/community_modules.py b/lib/python/qmk/community_modules.py
new file mode 100644
index 0000000000..f7e96a6b93
--- /dev/null
+++ b/lib/python/qmk/community_modules.py
@@ -0,0 +1,100 @@
+import os
+
+from pathlib import Path
+from functools import lru_cache
+
+from milc.attrdict import AttrDict
+
+from qmk.json_schema import json_load, validate, merge_ordered_dicts
+from qmk.util import truthy
+from qmk.constants import QMK_FIRMWARE, QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.path import under_qmk_firmware, under_qmk_userspace
+
+COMMUNITY_MODULE_JSON_FILENAME = 'qmk_module.json'
+
+
+class ModuleAPI(AttrDict):
+    def __init__(self, **kwargs):
+        super().__init__()
+        for key, value in kwargs.items():
+            self[key] = value
+
+
+@lru_cache(maxsize=1)
+def module_api_list():
+    module_definition_files = sorted(set(QMK_FIRMWARE.glob('data/constants/module_hooks/*.hjson')))
+    module_definition_jsons = [json_load(f) for f in module_definition_files]
+    module_definitions = merge_ordered_dicts(module_definition_jsons)
+    latest_module_version = module_definition_files[-1].stem
+    latest_module_version_parts = latest_module_version.split('.')
+
+    api_list = []
+    for name, mod in module_definitions.items():
+        api_list.append(ModuleAPI(
+            ret_type=mod['ret_type'],
+            name=name,
+            args=mod['args'],
+            call_params=mod.get('call_params', ''),
+            guard=mod.get('guard', None),
+            header=mod.get('header', None),
+        ))
+
+    return api_list, latest_module_version, latest_module_version_parts[0], latest_module_version_parts[1], latest_module_version_parts[2]
+
+
+def find_available_module_paths():
+    """Find all available modules.
+    """
+    search_dirs = []
+    if HAS_QMK_USERSPACE:
+        search_dirs.append(QMK_USERSPACE / 'modules')
+    search_dirs.append(QMK_FIRMWARE / 'modules')
+
+    modules = []
+    for search_dir in search_dirs:
+        for module_json_path in search_dir.rglob(COMMUNITY_MODULE_JSON_FILENAME):
+            modules.append(module_json_path.parent)
+    return modules
+
+
+def find_module_path(module):
+    """Find a module by name.
+    """
+    for module_path in find_available_module_paths():
+        # Ensure the module directory is under QMK Firmware or QMK Userspace
+        relative_path = under_qmk_firmware(module_path)
+        if not relative_path:
+            relative_path = under_qmk_userspace(module_path)
+        if not relative_path:
+            continue
+
+        lhs = str(relative_path.as_posix())[len('modules/'):]
+        rhs = str(Path(module).as_posix())
+
+        if relative_path and lhs == rhs:
+            return module_path
+    return None
+
+
+def load_module_json(module):
+    """Load a module JSON file.
+    """
+    module_path = find_module_path(module)
+    if not module_path:
+        raise FileNotFoundError(f'Module not found: {module}')
+
+    module_json = json_load(module_path / COMMUNITY_MODULE_JSON_FILENAME)
+
+    if not truthy(os.environ.get('SKIP_SCHEMA_VALIDATION'), False):
+        validate(module_json, 'qmk.community_module.v1')
+
+    module_json['module'] = module
+    module_json['module_path'] = module_path
+
+    return module_json
+
+
+def load_module_jsons(modules):
+    """Load the module JSON files, matching the specified order.
+    """
+    return list(map(load_module_json, modules))
diff --git a/lib/python/qmk/compilation_database.py b/lib/python/qmk/compilation_database.py
new file mode 100755
index 0000000000..851dc3f157
--- /dev/null
+++ b/lib/python/qmk/compilation_database.py
@@ -0,0 +1,140 @@
+"""Creates a compilation database for the given keyboard build.
+"""
+
+import json
+import os
+import re
+import shlex
+import shutil
+from functools import lru_cache
+from pathlib import Path
+from typing import Dict, Iterator, List
+
+from milc import cli
+
+from qmk.commands import find_make
+from qmk.constants import QMK_FIRMWARE
+
+
+@lru_cache(maxsize=10)
+def system_libs(binary: str) -> List[Path]:
+    """Find the system include directory that the given build tool uses.
+    """
+    cli.log.debug("searching for system library directory for binary: %s", binary)
+
+    # Actually query xxxxxx-gcc to find its include paths.
+    if binary.endswith("gcc") or binary.endswith("g++"):
+        # (TODO): Remove 'stdin' once 'input' no longer causes issues under MSYS
+        result = cli.run([binary, '-E', '-Wp,-v', '-'], capture_output=True, check=True, stdin=None, input='\n')
+        paths = []
+        for line in result.stderr.splitlines():
+            if line.startswith(" "):
+                paths.append(Path(line.strip()).resolve())
+        return paths
+
+    return list(Path(binary).resolve().parent.parent.glob("*/include")) if binary else []
+
+
+@lru_cache(maxsize=10)
+def cpu_defines(binary: str, compiler_args: str) -> List[str]:
+    cli.log.debug("gathering definitions for compilation: %s %s", binary, compiler_args)
+    if binary.endswith("gcc") or binary.endswith("g++"):
+        invocation = [binary, '-dM', '-E']
+        if binary.endswith("gcc"):
+            invocation.extend(['-x', 'c', '-std=gnu11'])
+        elif binary.endswith("g++"):
+            invocation.extend(['-x', 'c++', '-std=gnu++14'])
+        invocation.extend(shlex.split(compiler_args))
+        invocation.append('-')
+        result = cli.run(invocation, capture_output=True, check=True, stdin=None, input='\n')
+        define_args = []
+        for line in result.stdout.splitlines():
+            line_args = line.split(' ', 2)
+            if len(line_args) == 3 and line_args[0] == '#define':
+                define_args.append(f'-D{line_args[1]}={line_args[2]}')
+            elif len(line_args) == 2 and line_args[0] == '#define':
+                define_args.append(f'-D{line_args[1]}')
+
+        type_filter = re.compile(
+            r'^-D__(SIZE|INT|UINT|WINT|WCHAR|BYTE|SHRT|SIG|FLOAT|LONG|CHAR|SCHAR|DBL|FLT|LDBL|PTRDIFF|QQ|DQ|DA|HA|HQ|SA|SQ|TA|TQ|UDA|UDQ|UHA|UHQ|USQ|USA|UTQ|UTA|UQQ|UQA|ACCUM|FRACT|UACCUM|UFRACT|LACCUM|LFRACT|ULACCUM|ULFRACT|LLACCUM|LLFRACT|ULLACCUM|ULLFRACT|SACCUM|SFRACT|USACCUM|USFRACT)'
+        )
+        return list(sorted(set(filter(lambda x: not type_filter.match(x), define_args))))
+    return []
+
+
+file_re = re.compile(r'printf "Compiling: ([^"]+)')
+cmd_re = re.compile(r'LOG=\$\((.+?)&&')
+
+
+def parse_make_n(f: Iterator[str]) -> List[Dict[str, str]]:
+    """parse the output of `make -n <target>`
+
+    This function makes many assumptions about the format of your build log.
+    This happens to work right now for qmk.
+    """
+
+    state = 'start'
+    this_file = None
+    records = []
+    for line in f:
+        if state == 'start':
+            m = file_re.search(line)
+            if m:
+                this_file = m.group(1)
+                state = 'cmd'
+
+        if state == 'cmd':
+            assert this_file
+            m = cmd_re.search(line)
+            if m:
+                # we have a hit!
+                this_cmd = m.group(1)
+                args = shlex.split(this_cmd)
+                binary = shutil.which(args[0])
+                compiler_args = set(filter(lambda x: x.startswith('-m') or x.startswith('-f'), args))
+                for s in system_libs(binary):
+                    args += ['-isystem', '%s' % s]
+                args.extend(cpu_defines(binary, ' '.join(shlex.quote(s) for s in compiler_args)))
+                args[0] = binary
+                records.append({"arguments": args, "directory": str(QMK_FIRMWARE.resolve()), "file": this_file})
+                state = 'start'
+
+    return records
+
+
+def write_compilation_database(keyboard: str = None, keymap: str = None, output_path: Path = QMK_FIRMWARE / 'compile_commands.json', skip_clean: bool = False, command: List[str] = None, **env_vars) -> bool:
+    # Generate the make command for a specific keyboard/keymap.
+    if not command:
+        from qmk.build_targets import KeyboardKeymapBuildTarget  # Lazy load due to circular references
+        target = KeyboardKeymapBuildTarget(keyboard, keymap)
+        command = target.compile_command(dry_run=True, **env_vars)
+
+    if not command:
+        cli.log.error('You must supply both `--keyboard` and `--keymap`, or be in a directory for a keyboard or keymap.')
+        cli.echo('usage: qmk generate-compilation-database [-kb KEYBOARD] [-km KEYMAP]')
+        return False
+
+    # remove any environment variable overrides which could trip us up
+    env = os.environ.copy()
+    env.pop("MAKEFLAGS", None)
+
+    # re-use same executable as the main make invocation (might be gmake)
+    if not skip_clean:
+        clean_command = [find_make(), "clean"]
+        cli.log.info('Making clean with {fg_cyan}%s', ' '.join(clean_command))
+        cli.run(clean_command, capture_output=False, check=True, env=env)
+
+    cli.log.info('Gathering build instructions from {fg_cyan}%s', ' '.join(command))
+
+    result = cli.run(command, capture_output=True, check=True, env=env)
+    db = parse_make_n(result.stdout.splitlines())
+    if not db:
+        cli.log.error("Failed to parse output from make output:\n%s", result.stdout)
+        return False
+
+    cli.log.info("Found %s compile commands", len(db))
+
+    cli.log.info(f"Writing build database to {output_path}")
+    output_path.write_text(json.dumps(db, indent=4))
+
+    return True
diff --git a/lib/python/qmk/constants.py b/lib/python/qmk/constants.py
new file mode 100644
index 0000000000..e3e47c2bd2
--- /dev/null
+++ b/lib/python/qmk/constants.py
@@ -0,0 +1,327 @@
+"""Information that should be available to the python library.
+"""
+from os import environ
+from datetime import date
+from pathlib import Path
+
+from qmk.userspace import detect_qmk_userspace
+
+# The root of the qmk_firmware tree.
+QMK_FIRMWARE = Path.cwd()
+
+# The detected userspace tree
+QMK_USERSPACE = detect_qmk_userspace()
+
+# Whether or not we have a separate userspace directory
+HAS_QMK_USERSPACE = True if QMK_USERSPACE is not None else False
+
+# Upstream repo url
+QMK_FIRMWARE_UPSTREAM = 'qmk/qmk_firmware'
+
+# This is the number of directories under `qmk_firmware/keyboards` that will be traversed. This is currently a limitation of our make system.
+MAX_KEYBOARD_SUBFOLDERS = 5
+
+# Supported processor types
+CHIBIOS_PROCESSORS = 'cortex-m0', 'cortex-m0plus', 'cortex-m3', 'cortex-m4', 'MKL26Z64', 'MK20DX128', 'MK20DX256', 'MK64FX512', 'MK66FX1M0', 'RP2040', 'STM32F042', 'STM32F072', 'STM32F103', 'STM32F303', 'STM32F401', 'STM32F405', 'STM32F407', 'STM32F411', 'STM32F446', 'STM32G0B1', 'STM32G431', 'STM32G474', 'STM32H723', 'STM32H733', 'STM32L412', 'STM32L422', 'STM32L432', 'STM32L433', 'STM32L442', 'STM32L443', 'GD32VF103', 'WB32F3G71', 'WB32FQ95', 'AT32F415'
+LUFA_PROCESSORS = 'at90usb162', 'atmega16u2', 'atmega32u2', 'atmega16u4', 'atmega32u4', 'at90usb646', 'at90usb647', 'at90usb1286', 'at90usb1287', None
+VUSB_PROCESSORS = 'atmega32a', 'atmega328p', 'atmega328', 'attiny85'
+
+# Bootloaders of the supported processors
+MCU2BOOTLOADER = {
+    "RP2040": "rp2040",
+    "MKL26Z64": "halfkay",
+    "MK20DX128": "halfkay",
+    "MK20DX256": "halfkay",
+    "MK66FX1M0": "halfkay",
+    "STM32F042": "stm32-dfu",
+    "STM32F072": "stm32-dfu",
+    "STM32F103": "stm32duino",
+    "STM32F303": "stm32-dfu",
+    "STM32F401": "stm32-dfu",
+    "STM32F405": "stm32-dfu",
+    "STM32F407": "stm32-dfu",
+    "STM32F411": "stm32-dfu",
+    "STM32F446": "stm32-dfu",
+    "STM32G0B1": "stm32-dfu",
+    "STM32G431": "stm32-dfu",
+    "STM32G474": "stm32-dfu",
+    "STM32H723": "stm32-dfu",
+    "STM32H733": "stm32-dfu",
+    "STM32L412": "stm32-dfu",
+    "STM32L422": "stm32-dfu",
+    "STM32L432": "stm32-dfu",
+    "STM32L433": "stm32-dfu",
+    "STM32L442": "stm32-dfu",
+    "STM32L443": "stm32-dfu",
+    "GD32VF103": "gd32v-dfu",
+    "WB32F3G71": "wb32-dfu",
+    "WB32FQ95": "wb32-dfu",
+    "AT32F415": "at32-dfu",
+    "atmega16u2": "atmel-dfu",
+    "atmega32u2": "atmel-dfu",
+    "atmega16u4": "atmel-dfu",
+    "atmega32u4": "atmel-dfu",
+    "at90usb162": "atmel-dfu",
+    "at90usb646": "atmel-dfu",
+    "at90usb647": "atmel-dfu",
+    "at90usb1286": "atmel-dfu",
+    "at90usb1287": "atmel-dfu",
+    "atmega32a": "bootloadhid",
+    "atmega328p": "usbasploader",
+    "atmega328": "usbasploader",
+}
+
+# Map of legacy keycodes that can be automatically updated
+LEGACY_KEYCODES = {  # Comment here is to force multiline formatting
+    'RESET': 'QK_BOOT'
+}
+
+# Map VID:PID values to bootloaders
+BOOTLOADER_VIDS_PIDS = {
+    'atmel-dfu': {
+        ("03eb", "2fef"),  # ATmega16U2
+        ("03eb", "2ff0"),  # ATmega32U2
+        ("03eb", "2ff3"),  # ATmega16U4
+        ("03eb", "2ff4"),  # ATmega32U4
+        ("03eb", "2ff9"),  # AT90USB64
+        ("03eb", "2ffa"),  # AT90USB162
+        ("03eb", "2ffb")  # AT90USB128
+    },
+    'kiibohd': {("1c11", "b007")},
+    'stm32-dfu': {
+        ("1eaf", "0003"),  # STM32duino
+        ("0483", "df11")  # STM32 DFU
+    },
+    'apm32-dfu': {("314b", "0106")},
+    'gd32v-dfu': {("28e9", "0189")},
+    'wb32-dfu': {("342d", "dfa0")},
+    'at32-dfu': {("2e3c", "df11")},
+    'bootloadhid': {("16c0", "05df")},
+    'usbasploader': {("16c0", "05dc")},
+    'usbtinyisp': {("1782", "0c9f")},
+    'md-boot': {("03eb", "6124")},
+    'caterina': {
+        # pid.codes shared PID
+        ("1209", "2302"),  # Keyboardio Atreus 2 Bootloader
+        # Spark Fun Electronics
+        ("1b4f", "9203"),  # Pro Micro 3V3/8MHz
+        ("1b4f", "9205"),  # Pro Micro 5V/16MHz
+        ("1b4f", "9207"),  # LilyPad 3V3/8MHz (and some Pro Micro clones)
+        # Pololu Electronics
+        ("1ffb", "0101"),  # A-Star 32U4
+        # Arduino SA
+        ("2341", "0036"),  # Leonardo
+        ("2341", "0037"),  # Micro
+        # Adafruit Industries LLC
+        ("239a", "000c"),  # Feather 32U4
+        ("239a", "000d"),  # ItsyBitsy 32U4 3V3/8MHz
+        ("239a", "000e"),  # ItsyBitsy 32U4 5V/16MHz
+        # dog hunter AG
+        ("2a03", "0036"),  # Leonardo
+        ("2a03", "0037")  # Micro
+    },
+    'hid-bootloader': {
+        ("03eb", "2067"),  # QMK HID
+        ("16c0", "0478")  # PJRC halfkay
+    }
+}
+
+# Common format strings
+DATE_FORMAT = '%Y-%m-%d'
+DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S %Z'
+TIME_FORMAT = '%H:%M:%S'
+
+# Used when generating matrix locations
+COL_LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijilmnopqrstuvwxyz'
+ROW_LETTERS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnop'
+
+# Constants that should match their counterparts in make
+BUILD_DIR = environ.get('BUILD_DIR', '.build')
+INTERMEDIATE_OUTPUT_PREFIX = f'{BUILD_DIR}/obj_'
+
+# Headers for generated files
+GPL2_HEADER_C_LIKE = f'''\
+// Copyright {date.today().year} QMK
+// SPDX-License-Identifier: GPL-2.0-or-later
+'''
+
+GPL2_HEADER_SH_LIKE = f'''\
+# Copyright {date.today().year} QMK
+# SPDX-License-Identifier: GPL-2.0-or-later
+'''
+
+GENERATED_HEADER_C_LIKE = '''\
+/*******************************************************************************
+  88888888888 888      d8b                .d888 d8b 888               d8b
+      888     888      Y8P               d88P"  Y8P 888               Y8P
+      888     888                        888        888
+      888     88888b.  888 .d8888b       888888 888 888  .d88b.       888 .d8888b
+      888     888 "88b 888 88K           888    888 888 d8P  Y8b      888 88K
+      888     888  888 888 "Y8888b.      888    888 888 88888888      888 "Y8888b.
+      888     888  888 888      X88      888    888 888 Y8b.          888      X88
+      888     888  888 888  88888P'      888    888 888  "Y8888       888  88888P'
+                                                        888                 888
+                                                        888                 888
+                                                        888                 888
+     .d88b.   .d88b.  88888b.   .d88b.  888d888 8888b.  888888 .d88b.   .d88888
+    d88P"88b d8P  Y8b 888 "88b d8P  Y8b 888P"      "88b 888   d8P  Y8b d88" 888
+    888  888 88888888 888  888 88888888 888    .d888888 888   88888888 888  888
+    Y88b 888 Y8b.     888  888 Y8b.     888    888  888 Y88b. Y8b.     Y88b 888
+     "Y88888  "Y8888  888  888  "Y8888  888    "Y888888  "Y888 "Y8888   "Y88888
+         888
+    Y8b d88P
+     "Y88P"
+*******************************************************************************/
+'''
+
+GENERATED_HEADER_SH_LIKE = '''\
+################################################################################
+#
+# 88888888888 888      d8b                .d888 d8b 888               d8b
+#     888     888      Y8P               d88P"  Y8P 888               Y8P
+#     888     888                        888        888
+#     888     88888b.  888 .d8888b       888888 888 888  .d88b.       888 .d8888b
+#     888     888 "88b 888 88K           888    888 888 d8P  Y8b      888 88K
+#     888     888  888 888 "Y8888b.      888    888 888 88888888      888 "Y8888b.
+#     888     888  888 888      X88      888    888 888 Y8b.          888      X88
+#     888     888  888 888  88888P'      888    888 888  "Y8888       888  88888P'
+#
+#                                                       888                 888
+#                                                       888                 888
+#                                                       888                 888
+#    .d88b.   .d88b.  88888b.   .d88b.  888d888 8888b.  888888 .d88b.   .d88888
+#   d88P"88b d8P  Y8b 888 "88b d8P  Y8b 888P"      "88b 888   d8P  Y8b d88" 888
+#   888  888 88888888 888  888 88888888 888    .d888888 888   88888888 888  888
+#   Y88b 888 Y8b.     888  888 Y8b.     888    888  888 Y88b. Y8b.     Y88b 888
+#    "Y88888  "Y8888  888  888  "Y8888  888    "Y888888  "Y888 "Y8888   "Y88888
+#        888
+#   Y8b d88P
+#    "Y88P"
+#
+################################################################################
+'''
+
+LICENSE_TEXTS = [
+    (
+        'GPL-2.0-or-later', [
+            """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public License
+        as published by the Free Software Foundation; either version 2
+        of the License, or (at your option) any later version.
+        """, """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public License
+        as published by the Free Software Foundation; either version 2
+        of the License, or any later version.
+        """
+        ]
+    ),
+    ('GPL-2.0-only', ["""\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU General Public License as
+        published by the Free Software Foundation; version 2.
+        """]),
+    (
+        'GPL-3.0-or-later', [
+            """\
+        This program is free software: you can redistribute it and/or
+        modify it under the terms of the GNU General Public License as
+        published by the Free Software Foundation, either version 3 of
+        the License, or (at your option) any later version.
+        """, """\
+        This program is free software: you can redistribute it and/or
+        modify it under the terms of the GNU General Public License as
+        published by the Free Software Foundation, either version 3 of
+        the License, or any later version.
+        """
+        ]
+    ),
+    ('GPL-3.0-only', ["""\
+        This program is free software: you can redistribute it and/or
+        modify it under the terms of the GNU General Public License as
+        published by the Free Software Foundation, version 3.
+        """]),
+    (
+        'LGPL-2.1-or-later', [
+            """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 2.1
+        of the License, or (at your option) any later version.
+        """, """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 2.1
+        of the License, or any later version.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 2.1
+        of the License, or (at your option) any later version.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 2.1
+        of the License, or any later version.
+        """
+        ]
+    ),
+    (
+        'LGPL-2.1-only', [
+            """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License as
+        published by the Free Software Foundation; version 2.1.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License as
+        published by the Free Software Foundation; version 2.1.
+        """
+        ]
+    ),
+    (
+        'LGPL-3.0-or-later', [
+            """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 3
+        of the License, or (at your option) any later version.
+        """, """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 3
+        of the License, or any later version.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 3
+        of the License, or (at your option) any later version.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License
+        as published by the Free Software Foundation; either version 3
+        of the License, or any later version.
+        """
+        ]
+    ),
+    (
+        'LGPL-3.0-only', [
+            """\
+        This program is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License as
+        published by the Free Software Foundation; version 3.
+        """, """\
+        This library is free software; you can redistribute it and/or
+        modify it under the terms of the GNU Lesser General Public License as
+        published by the Free Software Foundation; version 3.
+        """
+        ]
+    ),
+    ('Apache-2.0', ["""\
+        Licensed under the Apache License, Version 2.0 (the "License");
+        you may not use this file except in compliance with the License.
+        """]),
+]
+
+JOYSTICK_AXES = ['x', 'y', 'z', 'rx', 'ry', 'rz']
diff --git a/lib/python/qmk/converter.py b/lib/python/qmk/converter.py
new file mode 100644
index 0000000000..bbd3531317
--- /dev/null
+++ b/lib/python/qmk/converter.py
@@ -0,0 +1,33 @@
+"""Functions to convert to and from QMK formats
+"""
+from collections import OrderedDict
+
+
+def kle2qmk(kle):
+    """Convert a KLE layout to QMK's layout format.
+    """
+    layout = []
+
+    for row in kle:
+        for key in row:
+            if key['decal']:
+                continue
+
+            qmk_key = OrderedDict(
+                label="",
+                x=key['column'],
+                y=key['row'],
+            )
+
+            if key['width'] != 1:
+                qmk_key['w'] = key['width']
+            if key['height'] != 1:
+                qmk_key['h'] = key['height']
+            if 'name' in key and key['name']:
+                qmk_key['label'] = key['name'].split('\n', 1)[0]
+            else:
+                del (qmk_key['label'])
+
+            layout.append(qmk_key)
+
+    return layout
diff --git a/lib/python/qmk/datetime.py b/lib/python/qmk/datetime.py
new file mode 100644
index 0000000000..4bffcc6217
--- /dev/null
+++ b/lib/python/qmk/datetime.py
@@ -0,0 +1,29 @@
+"""Functions to work with dates and times in a uniform way.
+
+The results of these functions are cached for 5 seconds to provide uniform time strings across short running processes. Long running processes that need more precise timekeeping should not use these functions.
+"""
+from time import gmtime, strftime
+
+from qmk.constants import DATE_FORMAT, DATETIME_FORMAT, TIME_FORMAT
+from qmk.decorators import lru_cache
+
+
+@lru_cache(timeout=5)
+def current_date():
+    """Returns the current time in UTZ as a formatted string.
+    """
+    return strftime(DATE_FORMAT, gmtime())
+
+
+@lru_cache(timeout=5)
+def current_datetime():
+    """Returns the current time in UTZ as a formatted string.
+    """
+    return strftime(DATETIME_FORMAT, gmtime())
+
+
+@lru_cache(timeout=5)
+def current_time():
+    """Returns the current time in UTZ as a formatted string.
+    """
+    return strftime(TIME_FORMAT, gmtime())
diff --git a/lib/python/qmk/decorators.py b/lib/python/qmk/decorators.py
new file mode 100644
index 0000000000..0cad55a483
--- /dev/null
+++ b/lib/python/qmk/decorators.py
@@ -0,0 +1,102 @@
+"""Helpful decorators that subcommands can use.
+"""
+import functools
+from time import monotonic
+
+from milc import cli
+
+from qmk.keyboard import find_keyboard_from_dir, keyboard_folder
+from qmk.keymap import find_keymap_from_dir
+
+
+def _get_subcommand_name():
+    """Handle missing cli.subcommand_name on older versions of milc
+    """
+    try:
+        return cli.subcommand_name
+    except AttributeError:
+        return cli._subcommand.__name__
+
+
+def automagic_keyboard(func):
+    """Sets `cli.config.<subcommand>.keyboard` based on environment.
+
+    This will rewrite cli.config.<subcommand>.keyboard if the user did not pass `--keyboard` and the directory they are currently in is a keyboard or keymap directory.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        cmd = _get_subcommand_name()
+
+        # TODO: Workaround for if config file contains "old" keyboard name
+        #         Potential long-term fix needs to be within global cli or milc
+        if cli.config_source[cmd]['keyboard'] == 'config_file':
+            cli.config[cmd]['keyboard'] = keyboard_folder(cli.config[cmd]['keyboard'])
+
+        # Ensure that `--keyboard` was not passed and CWD is under `qmk_firmware/keyboards`
+        if cli.config_source[cmd]['keyboard'] != 'argument':
+            keyboard = find_keyboard_from_dir()
+
+            if keyboard:
+                cli.config[cmd]['keyboard'] = keyboard
+                cli.config_source[cmd]['keyboard'] = 'keyboard_directory'
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def automagic_keymap(func):
+    """Sets `cli.config.<subcommand>.keymap` based on environment.
+
+    This will rewrite cli.config.<subcommand>.keymap if the user did not pass `--keymap` and the directory they are currently in is a keymap, layout, or user directory.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        cmd = _get_subcommand_name()
+
+        # Ensure that `--keymap` was not passed and that we're under `qmk_firmware`
+        if cli.config_source[cmd]['keymap'] != 'argument':
+            keymap_name, keymap_type = find_keymap_from_dir()
+
+            if keymap_name:
+                cli.config[cmd]['keymap'] = keymap_name
+                cli.config_source[cmd]['keymap'] = keymap_type
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def lru_cache(timeout=10, maxsize=128, typed=False):
+    """Least Recently Used Cache- cache the result of a function.
+
+    Args:
+
+        timeout
+            How many seconds to cache results for.
+
+        maxsize
+            The maximum size of the cache in bytes
+
+        typed
+            When `True` argument types will be taken into consideration, for example `3` and `3.0` will be treated as different keys.
+    """
+    def wrapper_cache(func):
+        func = functools.lru_cache(maxsize=maxsize, typed=typed)(func)
+        func.expiration = monotonic() + timeout
+
+        @functools.wraps(func)
+        def wrapped_func(*args, **kwargs):
+            if monotonic() >= func.expiration:
+                func.expiration = monotonic() + timeout
+
+                func.cache_clear()
+
+            return func(*args, **kwargs)
+
+        wrapped_func.cache_info = func.cache_info
+        wrapped_func.cache_clear = func.cache_clear
+
+        return wrapped_func
+
+    return wrapper_cache
diff --git a/lib/python/qmk/docs.py b/lib/python/qmk/docs.py
new file mode 100644
index 0000000000..75d2d60bda
--- /dev/null
+++ b/lib/python/qmk/docs.py
@@ -0,0 +1,61 @@
+"""Handlers for the QMK documentation generator (docusaurus).
+"""
+import shutil
+from pathlib import Path
+from subprocess import DEVNULL
+from os import chdir, environ, makedirs, pathsep
+from milc import cli
+
+from qmk.constants import QMK_FIRMWARE
+
+DOCS_PATH = QMK_FIRMWARE / 'docs'
+BUILDDEFS_PATH = QMK_FIRMWARE / 'builddefs' / 'docsgen'
+BUILD_PATH = QMK_FIRMWARE / '.build'
+CACHE_PATH = BUILD_PATH / 'cache'
+NODE_MODULES_PATH = BUILD_PATH / 'node_modules'
+BUILD_DOCS_PATH = BUILD_PATH / 'docs'
+DOXYGEN_PATH = BUILD_DOCS_PATH / 'static' / 'doxygen'
+
+
+def run_docs_command(verb, cmd_args=None):
+    environ['PATH'] += pathsep + str(NODE_MODULES_PATH / '.bin')
+
+    args = {'capture_output': False, 'check': True}
+    docs_env = environ.copy()
+    if cli.config.general.verbose:
+        docs_env['DEBUG'] = 'vitepress:*,vite:*'
+    args['env'] = docs_env
+
+    arg_list = ['yarn', verb]
+    if cmd_args:
+        arg_list.extend(cmd_args)
+
+    chdir(BUILDDEFS_PATH)
+    cli.run(arg_list, **args)
+
+
+def prepare_docs_build_area(is_production):
+    if is_production:
+        # Set up a symlink for docs to be inside builddefs -- vitepress can't handle source files in parent directories
+        try:
+            docs_link = Path(BUILDDEFS_PATH / 'docs')
+            if not docs_link.exists():
+                docs_link.symlink_to(DOCS_PATH)
+        except NotImplementedError:
+            cli.log.error('Symlinks are not supported on this platform.')
+            return False
+
+    if BUILD_DOCS_PATH.exists():
+        shutil.rmtree(BUILD_DOCS_PATH)
+
+    # When not verbose we want to hide all output
+    args = {'capture_output': False if cli.config.general.verbose else True, 'check': True, 'stdin': DEVNULL}
+
+    makedirs(DOXYGEN_PATH)
+    cli.log.info('Generating doxygen docs at %s', DOXYGEN_PATH)
+    cli.run(['doxygen', 'Doxyfile'], **args)
+
+    cli.log.info('Installing vitepress dependencies')
+    run_docs_command('install')
+
+    return True
diff --git a/lib/python/qmk/errors.py b/lib/python/qmk/errors.py
new file mode 100644
index 0000000000..1317687821
--- /dev/null
+++ b/lib/python/qmk/errors.py
@@ -0,0 +1,12 @@
+class NoSuchKeyboardError(Exception):
+    """Raised when we can't find a keyboard/keymap directory.
+    """
+    def __init__(self, message):
+        self.message = message
+
+
+class CppError(Exception):
+    """Raised when 'cpp' cannot process a file.
+    """
+    def __init__(self, message):
+        self.message = message
diff --git a/lib/python/qmk/flashers.py b/lib/python/qmk/flashers.py
new file mode 100644
index 0000000000..6b52f4d35a
--- /dev/null
+++ b/lib/python/qmk/flashers.py
@@ -0,0 +1,248 @@
+import platform
+import shutil
+import time
+import os
+import signal
+
+import usb.core
+
+from qmk.constants import BOOTLOADER_VIDS_PIDS
+from milc import cli
+
+# yapf: disable
+_PID_TO_MCU = {
+    '2fef': 'atmega16u2',
+    '2ff0': 'atmega32u2',
+    '2ff3': 'atmega16u4',
+    '2ff4': 'atmega32u4',
+    '2ff9': 'at90usb64',
+    '2ffa': 'at90usb162',
+    '2ffb': 'at90usb128'
+}
+
+AVRDUDE_MCU = {
+    'atmega32a': 'm32',
+    'atmega328p': 'm328p',
+    'atmega328': 'm328',
+}
+# yapf: enable
+
+
+class DelayedKeyboardInterrupt:
+    # Custom interrupt handler to delay the processing of Ctrl-C
+    # https://stackoverflow.com/a/21919644
+    def __enter__(self):
+        self.signal_received = False
+        self.old_handler = signal.signal(signal.SIGINT, self.handler)
+
+    def handler(self, sig, frame):
+        self.signal_received = (sig, frame)
+
+    def __exit__(self, type, value, traceback):
+        signal.signal(signal.SIGINT, self.old_handler)
+        if self.signal_received:
+            self.old_handler(*self.signal_received)
+
+
+# TODO: Make this more generic, so cli/doctor/check.py and flashers.py can share the code
+def _check_dfu_programmer_version():
+    # Return True if version is higher than 0.7.0: supports '--force'
+    check = cli.run(['dfu-programmer', '--version'], combined_output=True, timeout=5)
+    first_line = check.stdout.split('\n')[0]
+    version_number = first_line.split()[1]
+    maj, min_, bug = version_number.split('.')
+    if int(maj) >= 0 and int(min_) >= 7:
+        return True
+    else:
+        return False
+
+
+def _find_usb_device(vid_hex, pid_hex):
+    # WSL doesnt have access to USB - use powershell instead...?
+    if 'microsoft' in platform.uname().release.lower():
+        ret = cli.run(['powershell.exe', '-command', 'Get-PnpDevice -PresentOnly | Select-Object -Property InstanceId'])
+        if f'USB\\VID_{vid_hex:04X}&PID_{pid_hex:04X}' in ret.stdout:
+            return (vid_hex, pid_hex)
+    else:
+        with DelayedKeyboardInterrupt():
+            # PyUSB does not like to be interrupted by Ctrl-C
+            # therefore we catch the interrupt with a custom handler
+            # and only process it once pyusb finished
+            return usb.core.find(idVendor=vid_hex, idProduct=pid_hex)
+
+
+def _find_uf2_devices():
+    """Delegate to uf2conv.py as VID:PID pairs can potentially fluctuate more than other bootloaders
+    """
+    return cli.run(['util/uf2conv.py', '--list']).stdout.splitlines()
+
+
+def _find_bootloader():
+    # To avoid running forever in the background, only look for bootloaders for 10min
+    start_time = time.time()
+    while time.time() - start_time < 600:
+        for bl in BOOTLOADER_VIDS_PIDS:
+            for vid, pid in BOOTLOADER_VIDS_PIDS[bl]:
+                vid_hex = int(f'0x{vid}', 0)
+                pid_hex = int(f'0x{pid}', 0)
+                dev = _find_usb_device(vid_hex, pid_hex)
+                if dev:
+                    if bl == 'atmel-dfu':
+                        details = _PID_TO_MCU[pid]
+                    elif bl == 'caterina':
+                        details = (vid_hex, pid_hex)
+                    elif bl == 'hid-bootloader':
+                        if vid == '16c0' and pid == '0478':
+                            details = 'halfkay'
+                        else:
+                            details = 'qmk-hid'
+                    elif bl in {'apm32-dfu', 'at32-dfu', 'gd32v-dfu', 'kiibohd', 'stm32-dfu'}:
+                        details = (vid, pid)
+                    else:
+                        details = None
+                    return (bl, details)
+        if _find_uf2_devices():
+            return ('_uf2_compatible_', None)
+        time.sleep(0.1)
+    return (None, None)
+
+
+def _find_serial_port(vid, pid):
+    if 'windows' in cli.platform.lower():
+        from serial.tools.list_ports_windows import comports
+        platform = 'windows'
+    else:
+        from serial.tools.list_ports_posix import comports
+        platform = 'posix'
+
+    start_time = time.time()
+    # Caterina times out after 8 seconds
+    while time.time() - start_time < 8:
+        for port in comports():
+            port, desc, hwid = port
+            if f'{vid:04x}:{pid:04x}' in hwid.casefold():
+                if platform == 'windows':
+                    time.sleep(1)
+                    return port
+                else:
+                    start_time = time.time()
+                    # Wait until the port becomes writable before returning
+                    while time.time() - start_time < 8:
+                        if os.access(port, os.W_OK):
+                            return port
+                        else:
+                            time.sleep(0.5)
+                return None
+    return None
+
+
+def _flash_caterina(details, file):
+    port = _find_serial_port(details[0], details[1])
+    if port:
+        cli.run(['avrdude', '-p', 'atmega32u4', '-c', 'avr109', '-U', f'flash:w:{file}:i', '-P', port], capture_output=False)
+        return False
+    else:
+        return True
+
+
+def _flash_atmel_dfu(mcu, file):
+    force = '--force' if _check_dfu_programmer_version() else ''
+    cli.run(['dfu-programmer', mcu, 'erase', force], capture_output=False)
+    cli.run(['dfu-programmer', mcu, 'flash', force, file], capture_output=False)
+    cli.run(['dfu-programmer', mcu, 'reset'], capture_output=False)
+
+
+def _flash_hid_bootloader(mcu, details, file):
+    cmd = None
+    if details == 'halfkay':
+        if shutil.which('teensy_loader_cli'):
+            cmd = 'teensy_loader_cli'
+        elif shutil.which('teensy-loader-cli'):
+            cmd = 'teensy-loader-cli'
+
+    # Use 'hid_bootloader_cli' for QMK HID and as a fallback for HalfKay
+    if not cmd:
+        if shutil.which('hid_bootloader_cli'):
+            cmd = 'hid_bootloader_cli'
+        else:
+            return True
+
+    cli.run([cmd, f'-mmcu={mcu}', '-w', '-v', file], capture_output=False)
+
+
+def _flash_dfu_util(details, file):
+    # STM32duino
+    if details[0] == '1eaf' and details[1] == '0003':
+        cli.run(['dfu-util', '-a', '2', '-d', f'{details[0]}:{details[1]}', '-R', '-D', file], capture_output=False)
+    # kiibohd
+    elif details[0] == '1c11' and details[1] == 'b007':
+        cli.run(['dfu-util', '-a', '0', '-d', f'{details[0]}:{details[1]}', '-D', file], capture_output=False)
+    # STM32, APM32, AT32, or GD32V DFU
+    else:
+        cli.run(['dfu-util', '-a', '0', '-d', f'{details[0]}:{details[1]}', '-s', '0x08000000:leave', '-D', file], capture_output=False)
+
+
+def _flash_wb32_dfu_updater(file):
+    if shutil.which('wb32-dfu-updater_cli'):
+        cmd = 'wb32-dfu-updater_cli'
+    else:
+        return True
+
+    cli.run([cmd, '-t', '-s', '0x08000000', '-D', file], capture_output=False)
+
+
+def _flash_isp(mcu, programmer, file):
+    programmer = 'usbasp' if programmer == 'usbasploader' else 'usbtiny'
+    # Check if the provided mcu has an avrdude-specific name, otherwise pass on what the user provided
+    mcu = AVRDUDE_MCU.get(mcu, mcu)
+    cli.run(['avrdude', '-p', mcu, '-c', programmer, '-U', f'flash:w:{file}:i'], capture_output=False)
+
+
+def _flash_mdloader(file):
+    cli.run(['mdloader', '--first', '--download', file, '--restart'], capture_output=False)
+
+
+def _flash_uf2(file):
+    output = cli.run(['util/uf2conv.py', '--info', file]).stdout
+    if 'UF2 File' not in output:
+        return True
+
+    cli.run(['util/uf2conv.py', '--deploy', file], capture_output=False)
+
+
+def flasher(mcu, file):
+    # Avoid "expected string or bytes-like object, got 'WindowsPath" issues
+    file = file.as_posix()
+    bl, details = _find_bootloader()
+    # Add a small sleep to avoid race conditions
+    time.sleep(1)
+    if bl == 'atmel-dfu':
+        _flash_atmel_dfu(details, file)
+    elif bl == 'caterina':
+        if _flash_caterina(details, file):
+            return (True, "The Caterina bootloader was found but is not writable. Check 'qmk doctor' output for advice.")
+    elif bl == 'hid-bootloader':
+        if mcu:
+            if _flash_hid_bootloader(mcu, details, file):
+                return (True, "Please make sure 'teensy_loader_cli' or 'hid_bootloader_cli' is available on your system.")
+        else:
+            return (True, "Specifying the MCU with '-m' is necessary for HalfKay/HID bootloaders!")
+    elif bl in {'apm32-dfu', 'at32-dfu', 'gd32v-dfu', 'kiibohd', 'stm32-dfu'}:
+        _flash_dfu_util(details, file)
+    elif bl == 'wb32-dfu':
+        if _flash_wb32_dfu_updater(file):
+            return (True, "Please make sure 'wb32-dfu-updater_cli' is available on your system.")
+    elif bl == 'usbasploader' or bl == 'usbtinyisp':
+        if mcu:
+            _flash_isp(mcu, bl, file)
+        else:
+            return (True, "Specifying the MCU with '-m' is necessary for ISP flashing!")
+    elif bl == 'md-boot':
+        _flash_mdloader(file)
+    elif bl == '_uf2_compatible_':
+        if _flash_uf2(file):
+            return (True, "Flashing only supports uf2 format files.")
+    else:
+        return (True, "Known bootloader found but flashing not currently supported!")
+
+    return (False, None)
diff --git a/lib/python/qmk/git.py b/lib/python/qmk/git.py
new file mode 100644
index 0000000000..9d567475d8
--- /dev/null
+++ b/lib/python/qmk/git.py
@@ -0,0 +1,146 @@
+"""Functions for working with the QMK repo.
+"""
+from subprocess import DEVNULL
+from pathlib import Path
+
+from milc import cli
+
+from qmk.constants import QMK_FIRMWARE
+
+
+def git_get_version(repo_dir='.', check_dir='.'):
+    """Returns the current git version for a repo, or None.
+    """
+    git_describe_cmd = ['git', 'describe', '--abbrev=6', '--dirty', '--always', '--tags']
+
+    if repo_dir != '.':
+        repo_dir = Path('lib') / repo_dir
+
+    if check_dir != '.':
+        check_dir = repo_dir / check_dir
+
+    if Path(check_dir).exists():
+        git_describe = cli.run(git_describe_cmd, stdin=DEVNULL, cwd=repo_dir)
+
+        if git_describe.returncode == 0:
+            return git_describe.stdout.strip()
+
+        else:
+            cli.log.warning(f'"{" ".join(git_describe_cmd)}" returned error code {git_describe.returncode}')
+            print(git_describe.stderr)
+            return None
+
+    return None
+
+
+def git_get_username():
+    """Retrieves user's username from Git config, if set.
+    """
+    git_username = cli.run(['git', 'config', '--get', 'user.name'])
+
+    if git_username.returncode == 0 and git_username.stdout:
+        return git_username.stdout.strip()
+
+
+def git_get_branch():
+    """Returns the current branch for a repo, or None.
+    """
+    git_branch = cli.run(['git', 'branch', '--show-current'])
+    if not git_branch.returncode != 0 or not git_branch.stdout:
+        # Workaround for Git pre-2.22
+        git_branch = cli.run(['git', 'rev-parse', '--abbrev-ref', 'HEAD'])
+
+    if git_branch.returncode == 0:
+        return git_branch.stdout.strip()
+
+
+def git_get_tag():
+    """Returns the current tag for a repo, or None.
+    """
+    git_tag = cli.run(['git', 'describe', '--abbrev=0', '--tags'])
+    if git_tag.returncode == 0:
+        return git_tag.stdout.strip()
+
+
+def git_get_last_log_entry(branch_name):
+    """Retrieves the last log entry for the branch being worked on.
+    """
+    git_lastlog = cli.run(['git', '--no-pager', 'log', '--pretty=format:%ad (%h) -- %s', '--date=iso', '-n1', branch_name])
+
+    if git_lastlog.returncode == 0 and git_lastlog.stdout:
+        return git_lastlog.stdout.strip()
+
+
+def git_get_common_ancestor(branch_a, branch_b):
+    """Retrieves the common ancestor between for the two supplied branches.
+    """
+    git_merge_base = cli.run(['git', 'merge-base', branch_a, branch_b])
+    git_branchpoint_log = cli.run(['git', '--no-pager', 'log', '--pretty=format:%ad (%h) -- %s', '--date=iso', '-n1', git_merge_base.stdout.strip()])
+
+    if git_branchpoint_log.returncode == 0 and git_branchpoint_log.stdout:
+        return git_branchpoint_log.stdout.strip()
+
+
+def git_get_remotes():
+    """Returns the current remotes for a repo.
+    """
+    remotes = {}
+
+    git_remote_show_cmd = ['git', 'remote', 'show']
+    git_remote_get_cmd = ['git', 'remote', 'get-url']
+
+    git_remote_show = cli.run(git_remote_show_cmd)
+    if git_remote_show.returncode == 0:
+        for name in git_remote_show.stdout.splitlines():
+            git_remote_name = cli.run([*git_remote_get_cmd, name])
+            remotes[name.strip()] = {"url": git_remote_name.stdout.strip()}
+
+    return remotes
+
+
+def git_is_dirty():
+    """Returns 1 if repo is dirty, or 0 if clean
+    """
+    git_diff_staged_cmd = ['git', 'diff', '--quiet']
+    git_diff_unstaged_cmd = [*git_diff_staged_cmd, '--cached']
+
+    unstaged = cli.run(git_diff_staged_cmd)
+    staged = cli.run(git_diff_unstaged_cmd)
+
+    return unstaged.returncode != 0 or staged.returncode != 0
+
+
+def git_check_repo():
+    """Checks that the .git directory exists inside QMK_HOME.
+
+    This is a decent enough indicator that the qmk_firmware directory is a
+    proper Git repository, rather than a .zip download from GitHub.
+    """
+    dot_git_dir = QMK_FIRMWARE / '.git'
+
+    return dot_git_dir.is_dir()
+
+
+def git_check_deviation(active_branch):
+    """Return True if branch has custom commits
+    """
+    cli.run(['git', 'fetch', 'upstream', active_branch])
+    deviations = cli.run(['git', '--no-pager', 'log', f'upstream/{active_branch}...{active_branch}'])
+    return bool(deviations.returncode)
+
+
+def git_get_ignored_files(check_dir='.'):
+    """Return a list of files that would be captured by the current .gitignore
+    """
+    invalid = cli.run(['git', 'ls-files', '-c', '-o', '-i', '--exclude-from=.gitignore', check_dir])
+    if invalid.returncode != 0:
+        return []
+    return invalid.stdout.strip().splitlines()
+
+
+def git_get_qmk_hash():
+    output = cli.run(['git', 'rev-parse', '--short', 'HEAD'])
+    if output.returncode != 0:
+        return None
+
+    return output.stdout.strip()
diff --git a/lib/python/qmk/importers.py b/lib/python/qmk/importers.py
new file mode 100644
index 0000000000..3e7f305a43
--- /dev/null
+++ b/lib/python/qmk/importers.py
@@ -0,0 +1,201 @@
+from dotty_dict import dotty
+from datetime import date
+from pathlib import Path
+import json
+
+from qmk.git import git_get_username
+from qmk.json_schema import validate
+from qmk.path import keyboard, keymaps
+from qmk.constants import MCU2BOOTLOADER, LEGACY_KEYCODES
+from qmk.json_encoders import InfoJSONEncoder, KeymapJSONEncoder
+from qmk.json_schema import deep_update, json_load
+
+TEMPLATE = Path('data/templates/keyboard/')
+
+
+def replace_placeholders(src, dest, tokens):
+    """Replaces the given placeholders in each template file.
+    """
+    content = src.read_text()
+    for key, value in tokens.items():
+        content = content.replace(f'%{key}%', value)
+
+    dest.write_text(content)
+
+
+def _gen_dummy_keymap(name, info_data):
+    # Pick the first layout macro and just dump in KC_NOs or something?
+    (layout_name, layout_data), *_ = info_data["layouts"].items()
+    layout_length = len(layout_data["layout"])
+
+    keymap_data = {
+        "keyboard": name,
+        "layout": layout_name,
+        "layers": [["KC_NO" for _ in range(0, layout_length)]],
+    }
+
+    return keymap_data
+
+
+def _extract_kbfirmware_layout(kbf_data):
+    layout = []
+    for key in kbf_data['keyboard.keys']:
+        item = {
+            'matrix': [key['row'], key['col']],
+            'x': key['state']['x'],
+            'y': key['state']['y'],
+        }
+        if key['state']['w'] != 1:
+            item['w'] = key['state']['w']
+        if key['state']['h'] != 1:
+            item['h'] = key['state']['h']
+        layout.append(item)
+
+    return layout
+
+
+def _extract_kbfirmware_keymap(kbf_data):
+    keymap_data = {
+        'keyboard': kbf_data['keyboard.settings.name'].lower(),
+        'layout': 'LAYOUT',
+        'layers': [],
+    }
+
+    for i in range(15):
+        layer = []
+        for key in kbf_data['keyboard.keys']:
+            keycode = key['keycodes'][i]['id']
+            keycode = LEGACY_KEYCODES.get(keycode, keycode)
+            if '()' in keycode:
+                fields = key['keycodes'][i]['fields']
+                keycode = f'{keycode.split(")")[0]}{",".join(map(str, fields))})'
+            layer.append(keycode)
+        if set(layer) == {'KC_TRNS'}:
+            break
+        keymap_data['layers'].append(layer)
+
+    return keymap_data
+
+
+def import_keymap(keymap_data):
+    # Validate to ensure we don't have to deal with bad data - handles stdin/file
+    validate(keymap_data, 'qmk.keymap.v1')
+
+    kb_name = keymap_data['keyboard']
+    km_name = keymap_data['keymap']
+
+    km_folder = keymaps(kb_name)[0] / km_name
+    keyboard_keymap = km_folder / 'keymap.json'
+
+    # This is the deepest folder in the expected tree
+    keyboard_keymap.parent.mkdir(parents=True, exist_ok=True)
+
+    # Dump out all those lovely files
+    keyboard_keymap.write_text(json.dumps(keymap_data, cls=KeymapJSONEncoder, sort_keys=True))
+
+    return (kb_name, km_name)
+
+
+def import_keyboard(info_data, keymap_data=None):
+    # Validate to ensure we don't have to deal with bad data - handles stdin/file
+    validate(info_data, 'qmk.api.keyboard.v1')
+
+    # And validate some more as everything is optional
+    if not all(key in info_data for key in ['keyboard_name', 'layouts']):
+        raise ValueError('invalid json config')
+
+    kb_name = info_data['keyboard_name']
+
+    # bail
+    kb_folder = keyboard(kb_name)
+    if kb_folder.exists():
+        raise ValueError(f'Keyboard {{fg_cyan}}{kb_name}{{fg_reset}} already exists! Please choose a different name.')
+
+    if not keymap_data:
+        # TODO: if supports community then grab that instead
+        keymap_data = _gen_dummy_keymap(kb_name, info_data)
+
+    keyboard_json = kb_folder / 'keyboard.json'
+    keyboard_keymap = kb_folder / 'keymaps' / 'default' / 'keymap.json'
+
+    # begin with making the deepest folder in the tree
+    keyboard_keymap.parent.mkdir(parents=True, exist_ok=True)
+
+    user_name = git_get_username()
+    if not user_name:
+        user_name = 'TODO'
+
+    tokens = {  # Comment here is to force multiline formatting
+        'YEAR': str(date.today().year),
+        'KEYBOARD': kb_name,
+        'USER_NAME': user_name,
+        'REAL_NAME': user_name,
+    }
+
+    # Dump out all those lovely files
+    for file in list(TEMPLATE.iterdir()):
+        replace_placeholders(file, kb_folder / file.name, tokens)
+
+    temp = json_load(keyboard_json)
+    deep_update(temp, info_data)
+
+    keyboard_json.write_text(json.dumps(temp, cls=InfoJSONEncoder, sort_keys=True))
+    keyboard_keymap.write_text(json.dumps(keymap_data, cls=KeymapJSONEncoder, sort_keys=True))
+
+    return kb_name
+
+
+def import_kbfirmware(kbfirmware_data):
+    kbf_data = dotty(kbfirmware_data)
+
+    diode_direction = ["COL2ROW", "ROW2COL"][kbf_data['keyboard.settings.diodeDirection']]
+    mcu = ["atmega32u2", "atmega32u4", "at90usb1286"][kbf_data['keyboard.controller']]
+    bootloader = MCU2BOOTLOADER.get(mcu, "custom")
+
+    layout = _extract_kbfirmware_layout(kbf_data)
+    keymap_data = _extract_kbfirmware_keymap(kbf_data)
+
+    # convert to d/d info.json
+    info_data = dotty({
+        "keyboard_name": kbf_data['keyboard.settings.name'].lower(),
+        "processor": mcu,
+        "bootloader": bootloader,
+        "diode_direction": diode_direction,
+        "matrix_pins": {
+            "cols": kbf_data['keyboard.pins.col'],
+            "rows": kbf_data['keyboard.pins.row'],
+        },
+        "layouts": {
+            "LAYOUT": {
+                "layout": layout,
+            }
+        }
+    })
+
+    if kbf_data['keyboard.pins.num'] or kbf_data['keyboard.pins.caps'] or kbf_data['keyboard.pins.scroll']:
+        if kbf_data['keyboard.pins.num']:
+            info_data['indicators.num_lock'] = kbf_data['keyboard.pins.num']
+        if kbf_data['keyboard.pins.caps']:
+            info_data['indicators.caps_lock'] = kbf_data['keyboard.pins.caps']
+        if kbf_data['keyboard.pins.scroll']:
+            info_data['indicators.scroll_lock'] = kbf_data['keyboard.pins.scroll']
+
+    if kbf_data['keyboard.pins.rgb']:
+        info_data['rgblight.animations'] = {  # Comment here is to force multiline formatting
+            "breathing": True,
+            "rainbow_mood": True,
+            "rainbow_swirl": True,
+            "snake": True,
+            "knight": True,
+            "static_gradient": True,
+            "twinkle": True
+        }
+        info_data['rgblight.led_count'] = kbf_data['keyboard.settings.rgbNum']
+        info_data['ws2812.pin'] = kbf_data['keyboard.pins.rgb']
+
+    if kbf_data['keyboard.pins.led']:
+        info_data['backlight.levels'] = kbf_data['keyboard.settings.backlightLevels']
+        info_data['backlight.pin'] = kbf_data['keyboard.pins.led']
+
+    # delegate as if it were a regular keyboard import
+    return import_keyboard(info_data.to_dict(), keymap_data)
diff --git a/lib/python/qmk/info.py b/lib/python/qmk/info.py
new file mode 100644
index 0000000000..e07fa0ccae
--- /dev/null
+++ b/lib/python/qmk/info.py
@@ -0,0 +1,1131 @@
+"""Functions that help us generate and use info.json files.
+"""
+import re
+import os
+from pathlib import Path
+import jsonschema
+from dotty_dict import dotty
+from enum import IntFlag
+
+from milc import cli
+
+from qmk.constants import COL_LETTERS, ROW_LETTERS, CHIBIOS_PROCESSORS, LUFA_PROCESSORS, VUSB_PROCESSORS, JOYSTICK_AXES
+from qmk.c_parse import find_layouts, parse_config_h_file, find_led_config
+from qmk.json_schema import deep_update, json_load, validate
+from qmk.keyboard import config_h, rules_mk
+from qmk.commands import parse_configurator_json
+from qmk.makefile import parse_rules_mk_file
+from qmk.math_ops import compute
+from qmk.util import maybe_exit, truthy
+
+true_values = ['1', 'on', 'yes']
+false_values = ['0', 'off', 'no']
+
+
+class LedFlags(IntFlag):
+    ALL = 0xFF
+    NONE = 0x00
+    MODIFIER = 0x01
+    UNDERGLOW = 0x02
+    KEYLIGHT = 0x04
+    INDICATOR = 0x08
+
+
+def _keyboard_in_layout_name(keyboard, layout):
+    """Validate that a layout macro does not contain name of keyboard
+    """
+    # TODO: reduce this list down
+    safe_layout_tokens = {
+        'ansi',
+        'iso',
+        'jp',
+        'jis',
+        'ortho',
+        'wkl',
+        'tkl',
+        'preonic',
+        'planck',
+    }
+
+    # Ignore tokens like 'split_3x7_4' or just '2x4'
+    layout = re.sub(r"_split_\d+x\d+_\d+", '', layout)
+    layout = re.sub(r"_\d+x\d+", '', layout)
+
+    name_fragments = set(keyboard.split('/')) - safe_layout_tokens
+
+    return any(fragment in layout for fragment in name_fragments)
+
+
+def _valid_community_layout(layout):
+    """Validate that a declared community list exists
+    """
+    return (Path('layouts/default') / layout).exists()
+
+
+def _get_key_left_position(key):
+    # Special case for ISO enter
+    return key['x'] - 0.25 if key.get('h', 1) == 2 and key.get('w', 1) == 1.25 else key['x']
+
+
+def _find_invalid_encoder_index(info_data):
+    """Perform additional validation of encoders
+    """
+    enc_left = info_data.get('encoder', {}).get('rotary', [])
+    enc_right = []
+
+    if info_data.get('split', {}).get('enabled', False):
+        enc_right = info_data.get('split', {}).get('encoder', {}).get('right', {}).get('rotary', enc_left)
+
+    enc_count = len(enc_left) + len(enc_right)
+
+    ret = []
+    layouts = info_data.get('layouts', {})
+    for layout_name, layout_data in layouts.items():
+        found = set()
+        for key in layout_data['layout']:
+            if 'encoder' in key:
+                if enc_count == 0:
+                    ret.append((layout_name, key['encoder'], 'non-configured'))
+                elif key['encoder'] >= enc_count:
+                    ret.append((layout_name, key['encoder'], 'out of bounds'))
+                elif key['encoder'] in found:
+                    ret.append((layout_name, key['encoder'], 'duplicate'))
+                found.add(key['encoder'])
+
+    return ret
+
+
+def _validate_build_target(keyboard, info_data):
+    """Non schema checks
+    """
+    keyboard_json_path = Path('keyboards') / keyboard / 'keyboard.json'
+    config_files = find_info_json(keyboard)
+
+    # keyboard.json can only exist at the deepest part of the tree
+    keyboard_json_count = 0
+    for info_file in config_files:
+        if info_file.name == 'keyboard.json':
+            keyboard_json_count += 1
+            if info_file != keyboard_json_path:
+                _log_error(info_data, f'Invalid keyboard.json location detected: {info_file}.')
+
+    # No keyboard.json next to info.json
+    for conf_file in config_files:
+        if conf_file.name == 'keyboard.json':
+            info_file = conf_file.parent / 'info.json'
+            if info_file.exists():
+                _log_error(info_data, f'Invalid info.json location detected: {info_file}.')
+
+    # Moving forward keyboard.json should be used as a build target
+    if keyboard_json_count == 0:
+        _log_warning(info_data, 'Build marker "keyboard.json" not found.')
+
+
+def _validate_layouts(keyboard, info_data):  # noqa C901
+    """Non schema checks
+    """
+    col_num = info_data.get('matrix_size', {}).get('cols', 0)
+    row_num = info_data.get('matrix_size', {}).get('rows', 0)
+    layouts = info_data.get('layouts', {})
+    layout_aliases = info_data.get('layout_aliases', {})
+    community_layouts = info_data.get('community_layouts', [])
+    community_layouts_names = list(map(lambda layout: f'LAYOUT_{layout}', community_layouts))
+
+    # Make sure we have at least one layout
+    if len(layouts) == 0 or all(not layout.get('json_layout', False) for layout in layouts.values()):
+        _log_error(info_data, 'No LAYOUTs defined! Need at least one layout defined in info.json.')
+
+    # Make sure all layouts are DD
+    for layout_name, layout_data in layouts.items():
+        if layout_data.get('c_macro', False):
+            _log_error(info_data, f'{layout_name}: Layout macro should not be defined within ".h" files.')
+
+    # Make sure all matrix values are in bounds
+    for layout_name, layout_data in layouts.items():
+        for index, key_data in enumerate(layout_data['layout']):
+            row, col = key_data['matrix']
+            key_name = key_data.get('label', f'k{ROW_LETTERS[row]}{COL_LETTERS[col]}')
+            if row >= row_num:
+                _log_error(info_data, f'{layout_name}: Matrix row for key {index} ({key_name}) is {row} but must be less than {row_num}')
+            if col >= col_num:
+                _log_error(info_data, f'{layout_name}: Matrix column for key {index} ({key_name}) is {col} but must be less than {col_num}')
+
+    # Reject duplicate matrix locations
+    for layout_name, layout_data in layouts.items():
+        seen = set()
+        for index, key_data in enumerate(layout_data['layout']):
+            key = f"{key_data['matrix']}"
+            if key in seen:
+                _log_error(info_data, f'{layout_name}: Matrix location for key {index} is not unique {key_data}')
+            seen.add(key)
+
+    # Warn if physical positions are offset (at least one key should be at x=0, and at least one key at y=0)
+    for layout_name, layout_data in layouts.items():
+        offset_x = min([_get_key_left_position(k) for k in layout_data['layout']])
+        if offset_x > 0:
+            _log_warning(info_data, f'Layout "{layout_name}" is offset on X axis by {offset_x}')
+
+        offset_y = min([k['y'] for k in layout_data['layout']])
+        if offset_y > 0:
+            _log_warning(info_data, f'Layout "{layout_name}" is offset on Y axis by {offset_y}')
+
+    # Providing only LAYOUT_all "because I define my layouts in a 3rd party tool"
+    if len(layouts) == 1 and 'LAYOUT_all' in layouts:
+        _log_warning(info_data, '"LAYOUT_all" should be "LAYOUT" unless additional layouts are provided.')
+
+    # Extended layout name checks - ignoring community_layouts and "safe" values
+    potential_layouts = set(layouts.keys()) - set(community_layouts_names)
+    for layout in potential_layouts:
+        if _keyboard_in_layout_name(keyboard, layout):
+            _log_warning(info_data, f'Layout "{layout}" should not contain name of keyboard.')
+
+    # Filter out any non-existing community layouts
+    for layout in community_layouts:
+        if not _valid_community_layout(layout):
+            # Ignore layout from future checks
+            info_data['community_layouts'].remove(layout)
+            _log_error(info_data, 'Claims to support a community layout that does not exist: %s' % (layout))
+
+    # Make sure we supply layout macros for the community layouts we claim to support
+    for layout_name in community_layouts_names:
+        if layout_name not in layouts and layout_name not in layout_aliases:
+            _log_error(info_data, 'Claims to support community layout %s but no %s() macro found' % (layout, layout_name))
+
+
+def _validate_keycodes(keyboard, info_data):
+    """Non schema checks
+    """
+    # keycodes with length > 7 must have short forms for visualisation purposes
+    for decl in info_data.get('keycodes', []):
+        if len(decl["key"]) > 7:
+            if not decl.get("aliases", []):
+                _log_error(info_data, f'Keycode {decl["key"]} has no short form alias')
+
+
+def _validate_encoders(keyboard, info_data):
+    """Non schema checks
+    """
+    # encoder IDs in layouts must be in range and not duplicated
+    found = _find_invalid_encoder_index(info_data)
+    for layout_name, encoder_index, reason in found:
+        _log_error(info_data, f'Layout "{layout_name}" contains {reason} encoder index {encoder_index}.')
+
+
+def _validate(keyboard, info_data):
+    """Perform various validation on the provided info.json data
+    """
+    # First validate against the jsonschema
+    try:
+        validate(info_data, 'qmk.api.keyboard.v1')
+
+        # Additional validation
+        _validate_build_target(keyboard, info_data)
+        _validate_layouts(keyboard, info_data)
+        _validate_keycodes(keyboard, info_data)
+        _validate_encoders(keyboard, info_data)
+
+    except jsonschema.ValidationError as e:
+        json_path = '.'.join([str(p) for p in e.absolute_path])
+        cli.log.error('Invalid API data: %s: %s: %s', keyboard, json_path, e.message)
+        maybe_exit(1)
+
+
+def info_json(keyboard, force_layout=None):
+    """Generate the info.json data for a specific keyboard.
+    """
+    info_data = {
+        'keyboard_name': str(keyboard),
+        'keyboard_folder': str(keyboard),
+        'keymaps': {},
+        'layouts': {},
+        'parse_errors': [],
+        'parse_warnings': [],
+        'maintainer': 'qmk',
+    }
+
+    # Populate layout data
+    layouts, aliases = _search_keyboard_h(keyboard)
+
+    if aliases:
+        info_data['layout_aliases'] = aliases
+
+    for layout_name, layout_json in layouts.items():
+        if not layout_name.startswith('LAYOUT_kc'):
+            layout_json['c_macro'] = True
+            layout_json['json_layout'] = False
+            info_data['layouts'][layout_name] = layout_json
+
+    # Merge in the data from info.json, config.h, and rules.mk
+    info_data = merge_info_jsons(keyboard, info_data)
+    info_data = _process_defaults(info_data)
+    info_data = _extract_rules_mk(info_data, rules_mk(str(keyboard)))
+    info_data = _extract_config_h(info_data, config_h(str(keyboard)))
+
+    # Ensure that we have various calculated values
+    info_data = _matrix_size(info_data)
+    info_data = _joystick_axis_count(info_data)
+    info_data = _matrix_masked(info_data)
+
+    # Merge in data from <keyboard.c>
+    info_data = _extract_led_config(info_data, str(keyboard))
+
+    # Force a community layout if requested
+    community_layouts = info_data.get("community_layouts", [])
+    if force_layout in community_layouts:
+        info_data["community_layouts"] = [force_layout]
+
+    # Validate
+    # Skip processing if necessary
+    if not truthy(os.environ.get('SKIP_SCHEMA_VALIDATION'), False):
+        _validate(keyboard, info_data)
+
+    # Check that the reported matrix size is consistent with the actual matrix size
+    _check_matrix(info_data)
+
+    return info_data
+
+
+def _extract_features(info_data, rules):
+    """Find all the features enabled in rules.mk.
+    """
+    # Process booleans rules
+    for key, value in rules.items():
+        if key.endswith('_ENABLE'):
+            key = '_'.join(key.split('_')[:-1]).lower()
+            value = True if value.lower() in true_values else False if value.lower() in false_values else value
+
+            if key in ['lto']:
+                continue
+
+            if 'config_h_features' not in info_data:
+                info_data['config_h_features'] = {}
+
+            if 'features' not in info_data:
+                info_data['features'] = {}
+
+            if key in info_data['features']:
+                _log_warning(info_data, 'Feature %s is specified in both info.json (%s) and rules.mk (%s). The rules.mk value wins.' % (key, info_data['features'], value))
+
+            info_data['features'][key] = value
+            info_data['config_h_features'][key] = value
+
+    return info_data
+
+
+def _extract_matrix_rules(info_data, rules):
+    """Find all the features enabled in rules.mk.
+    """
+    if rules.get('CUSTOM_MATRIX', 'no') != 'no':
+        if 'matrix_pins' in info_data and 'custom' in info_data['matrix_pins']:
+            _log_warning(info_data, 'Custom Matrix is specified in both info.json and rules.mk, the rules.mk values win.')
+
+        if 'matrix_pins' not in info_data:
+            info_data['matrix_pins'] = {}
+
+        if rules['CUSTOM_MATRIX'] == 'lite':
+            info_data['matrix_pins']['custom_lite'] = True
+        else:
+            info_data['matrix_pins']['custom'] = True
+
+    return info_data
+
+
+def _pin_name(pin):
+    """Returns the proper representation for a pin.
+    """
+    pin = pin.strip()
+
+    if not pin:
+        return None
+
+    elif pin.isdigit():
+        return int(pin)
+
+    elif pin == 'NO_PIN':
+        return None
+
+    return pin
+
+
+def _extract_pins(pins):
+    """Returns a list of pins from a comma separated string of pins.
+    """
+    return [_pin_name(pin) for pin in pins.split(',')]
+
+
+def _extract_2d_array(raw):
+    """Return a 2d array of strings
+    """
+    out_array = []
+
+    while raw[-1] != '}':
+        raw = raw[:-1]
+
+    for row in raw.split('},{'):
+        if row.startswith('{'):
+            row = row[1:]
+
+        if row.endswith('}'):
+            row = row[:-1]
+
+        out_array.append([])
+
+        for val in row.split(','):
+            out_array[-1].append(val)
+
+    return out_array
+
+
+def _extract_2d_int_array(raw):
+    """Return a 2d array of ints
+    """
+    ret = _extract_2d_array(raw)
+
+    return [list(map(int, x)) for x in ret]
+
+
+def _extract_direct_matrix(direct_pins):
+    """extract direct_matrix
+    """
+    direct_pin_array = _extract_2d_array(direct_pins)
+
+    for i in range(len(direct_pin_array)):
+        for j in range(len(direct_pin_array[i])):
+            if direct_pin_array[i][j] == 'NO_PIN':
+                direct_pin_array[i][j] = None
+
+    return direct_pin_array
+
+
+def _extract_audio(info_data, config_c):
+    """Populate data about the audio configuration
+    """
+    audio_pins = []
+
+    for pin in 'B5', 'B6', 'B7', 'C4', 'C5', 'C6':
+        if config_c.get(f'{pin}_AUDIO'):
+            audio_pins.append(pin)
+
+    if audio_pins:
+        info_data['audio'] = {'pins': audio_pins}
+
+
+def _extract_encoders_values(config_c, postfix=''):
+    """Common encoder extraction logic
+    """
+    a_pad = config_c.get(f'ENCODER_A_PINS{postfix}', '').replace(' ', '')[1:-1]
+    b_pad = config_c.get(f'ENCODER_B_PINS{postfix}', '').replace(' ', '')[1:-1]
+    resolutions = config_c.get(f'ENCODER_RESOLUTIONS{postfix}', '').replace(' ', '')[1:-1]
+
+    default_resolution = config_c.get('ENCODER_RESOLUTION', None)
+
+    if a_pad and b_pad:
+        a_pad = list(filter(None, a_pad.split(',')))
+        b_pad = list(filter(None, b_pad.split(',')))
+        resolutions = list(filter(None, resolutions.split(',')))
+        if default_resolution:
+            resolutions += [default_resolution] * (len(a_pad) - len(resolutions))
+
+        encoders = []
+        for index in range(len(a_pad)):
+            encoder = {'pin_a': a_pad[index], 'pin_b': b_pad[index]}
+            if index < len(resolutions):
+                encoder['resolution'] = int(resolutions[index])
+            encoders.append(encoder)
+
+        return encoders
+
+
+def _extract_encoders(info_data, config_c):
+    """Populate data about encoder pins
+    """
+    encoders = _extract_encoders_values(config_c)
+    if encoders:
+        if 'encoder' not in info_data:
+            info_data['encoder'] = {}
+
+        if 'rotary' in info_data['encoder']:
+            _log_warning(info_data, 'Encoder config is specified in both config.h (%s) and info.json (%s). The config.h value wins.' % (encoders, info_data['encoder']['rotary']))
+
+        info_data['encoder']['rotary'] = encoders
+
+    # TODO: some logic still assumes ENCODER_ENABLED would partially create encoder dict
+    if info_data.get('features', {}).get('encoder', False):
+        if 'encoder' not in info_data:
+            info_data['encoder'] = {}
+        info_data['encoder']['enabled'] = True
+
+
+def _extract_split_encoders(info_data, config_c):
+    """Populate data about split encoder pins
+    """
+    encoders = _extract_encoders_values(config_c, '_RIGHT')
+    if encoders:
+        if 'split' not in info_data:
+            info_data['split'] = {}
+
+        if 'encoder' not in info_data['split']:
+            info_data['split']['encoder'] = {}
+
+        if 'right' not in info_data['split']['encoder']:
+            info_data['split']['encoder']['right'] = {}
+
+        if 'rotary' in info_data['split']['encoder']['right']:
+            _log_warning(info_data, 'Encoder config is specified in both config.h and info.json (encoder.rotary) (Value: %s), the config.h value wins.' % info_data['split']['encoder']['right']['rotary'])
+
+        info_data['split']['encoder']['right']['rotary'] = encoders
+
+
+def _extract_secure_unlock(info_data, config_c):
+    """Populate data about the secure unlock sequence
+    """
+    unlock = config_c.get('SECURE_UNLOCK_SEQUENCE', '').replace(' ', '')[1:-1]
+    if unlock:
+        unlock_array = _extract_2d_int_array(unlock)
+        if 'secure' not in info_data:
+            info_data['secure'] = {}
+
+        if 'unlock_sequence' in info_data['secure']:
+            _log_warning(info_data, 'Secure unlock sequence is specified in both config.h (SECURE_UNLOCK_SEQUENCE) and info.json (secure.unlock_sequence) (Value: %s), the config.h value wins.' % info_data['secure']['unlock_sequence'])
+
+        info_data['secure']['unlock_sequence'] = unlock_array
+
+
+def _extract_split_handedness(info_data, config_c):
+    # Migrate
+    split = info_data.get('split', {})
+    if 'matrix_grid' in split:
+        split['handedness'] = split.get('handedness', {})
+        split['handedness']['matrix_grid'] = split.pop('matrix_grid')
+
+
+def _extract_split_serial(info_data, config_c):
+    # Migrate
+    split = info_data.get('split', {})
+    if 'soft_serial_pin' in split:
+        split['serial'] = split.get('serial', {})
+        split['serial']['pin'] = split.pop('soft_serial_pin')
+    if 'soft_serial_speed' in split:
+        split['serial'] = split.get('serial', {})
+        split['serial']['speed'] = split.pop('soft_serial_speed')
+
+
+def _extract_split_transport(info_data, config_c):
+    # Figure out the transport method
+    if config_c.get('USE_I2C') is True:
+        if 'split' not in info_data:
+            info_data['split'] = {}
+
+        if 'transport' not in info_data['split']:
+            info_data['split']['transport'] = {}
+
+        if 'protocol' in info_data['split']['transport']:
+            _log_warning(info_data, 'Split transport is specified in both config.h (USE_I2C) and info.json (split.transport.protocol) (Value: %s), the config.h value wins.' % info_data['split']['transport'])
+
+        info_data['split']['transport']['protocol'] = 'i2c'
+
+    # Ignore transport defaults if "SPLIT_KEYBOARD" is unset
+    elif 'enabled' in info_data.get('split', {}):
+        if 'split' not in info_data:
+            info_data['split'] = {}
+
+        if 'transport' not in info_data['split']:
+            info_data['split']['transport'] = {}
+
+        if 'protocol' not in info_data['split']['transport']:
+            info_data['split']['transport']['protocol'] = 'serial'
+
+    # Migrate
+    transport = info_data.get('split', {}).get('transport', {})
+    if 'sync_matrix_state' in transport:
+        transport['sync'] = transport.get('sync', {})
+        transport['sync']['matrix_state'] = transport.pop('sync_matrix_state')
+    if 'sync_modifiers' in transport:
+        transport['sync'] = transport.get('sync', {})
+        transport['sync']['modifiers'] = transport.pop('sync_modifiers')
+
+
+def _extract_split_right_pins(info_data, config_c):
+    # Figure out the right half matrix pins
+    row_pins = config_c.get('MATRIX_ROW_PINS_RIGHT', '').replace('{', '').replace('}', '').strip()
+    col_pins = config_c.get('MATRIX_COL_PINS_RIGHT', '').replace('{', '').replace('}', '').strip()
+    direct_pins = config_c.get('DIRECT_PINS_RIGHT', '').replace(' ', '')[1:-1]
+
+    if row_pins or col_pins or direct_pins:
+        if info_data.get('split', {}).get('matrix_pins', {}).get('right', None):
+            _log_warning(info_data, 'Right hand matrix data is specified in both info.json and config.h, the config.h values win.')
+
+        if 'split' not in info_data:
+            info_data['split'] = {}
+
+        if 'matrix_pins' not in info_data['split']:
+            info_data['split']['matrix_pins'] = {}
+
+        if 'right' not in info_data['split']['matrix_pins']:
+            info_data['split']['matrix_pins']['right'] = {}
+
+        if col_pins:
+            info_data['split']['matrix_pins']['right']['cols'] = _extract_pins(col_pins)
+
+        if row_pins:
+            info_data['split']['matrix_pins']['right']['rows'] = _extract_pins(row_pins)
+
+        if direct_pins:
+            info_data['split']['matrix_pins']['right']['direct'] = _extract_direct_matrix(direct_pins)
+
+
+def _extract_matrix_info(info_data, config_c):
+    """Populate the matrix information.
+    """
+    row_pins = config_c.get('MATRIX_ROW_PINS', '').replace('{', '').replace('}', '').strip()
+    col_pins = config_c.get('MATRIX_COL_PINS', '').replace('{', '').replace('}', '').strip()
+    direct_pins = config_c.get('DIRECT_PINS', '').replace(' ', '')[1:-1]
+
+    if 'MATRIX_ROWS' in config_c and 'MATRIX_COLS' in config_c:
+        if 'matrix_size' in info_data:
+            _log_warning(info_data, 'Matrix size is specified in both info.json and config.h, the config.h values win.')
+
+        info_data['matrix_size'] = {
+            'cols': compute(config_c.get('MATRIX_COLS', '0')),
+            'rows': compute(config_c.get('MATRIX_ROWS', '0')),
+        }
+
+    if row_pins and col_pins:
+        if 'matrix_pins' in info_data and 'cols' in info_data['matrix_pins'] and 'rows' in info_data['matrix_pins']:
+            _log_warning(info_data, 'Matrix pins are specified in both info.json and config.h, the config.h values win.')
+
+        if 'matrix_pins' not in info_data:
+            info_data['matrix_pins'] = {}
+
+        info_data['matrix_pins']['cols'] = _extract_pins(col_pins)
+        info_data['matrix_pins']['rows'] = _extract_pins(row_pins)
+
+    if direct_pins:
+        if 'matrix_pins' in info_data and 'direct' in info_data['matrix_pins']:
+            _log_warning(info_data, 'Direct pins are specified in both info.json and config.h, the config.h values win.')
+
+        if 'matrix_pins' not in info_data:
+            info_data['matrix_pins'] = {}
+
+        info_data['matrix_pins']['direct'] = _extract_direct_matrix(direct_pins)
+
+    return info_data
+
+
+def _config_to_json(key_type, config_value):
+    """Convert config value using spec
+    """
+    if key_type.startswith('array'):
+        if key_type.count('.') > 1:
+            raise Exception(f"Conversion of {key_type} not possible")
+
+        if '.' in key_type:
+            key_type, array_type = key_type.split('.', 1)
+        else:
+            array_type = None
+
+        config_value = config_value.replace('{', '').replace('}', '').strip()
+
+        if array_type == 'int':
+            return list(map(int, config_value.split(',')))
+        else:
+            return list(map(str.strip, config_value.split(',')))
+
+    elif key_type in ['bool', 'flag']:
+        if isinstance(config_value, bool):
+            return config_value
+        return config_value in true_values
+
+    elif key_type == 'hex':
+        return '0x' + config_value[2:].upper()
+
+    elif key_type == 'list':
+        return config_value.split()
+
+    elif key_type == 'int':
+        return int(config_value)
+
+    elif key_type == 'str':
+        return config_value.strip('"').replace('\\"', '"').replace('\\\\', '\\')
+
+    elif key_type == 'bcd_version':
+        major = int(config_value[2:4])
+        minor = int(config_value[4])
+        revision = int(config_value[5])
+
+        return f'{major}.{minor}.{revision}'
+
+    return config_value
+
+
+def _extract_config_h(info_data, config_c):
+    """Pull some keyboard information from existing config.h files
+    """
+    # Pull in data from the json map
+    dotty_info = dotty(info_data)
+    info_config_map = json_load(Path('data/mappings/info_config.hjson'))
+
+    for config_key, info_dict in info_config_map.items():
+        info_key = info_dict['info_key']
+        key_type = info_dict.get('value_type', 'raw')
+
+        try:
+            replace_with = info_dict.get('replace_with')
+            if config_key in config_c and info_dict.get('invalid', False):
+                if replace_with:
+                    _log_error(info_data, '%s in config.h is no longer a valid option and should be replaced with %s' % (config_key, replace_with))
+                else:
+                    _log_error(info_data, '%s in config.h is no longer a valid option and should be removed' % config_key)
+            elif config_key in config_c and info_dict.get('deprecated', False):
+                if replace_with:
+                    _log_warning(info_data, '%s in config.h is deprecated in favor of %s and will be removed at a later date' % (config_key, replace_with))
+                else:
+                    _log_warning(info_data, '%s in config.h is deprecated and will be removed at a later date' % config_key)
+
+            if config_key in config_c and info_dict.get('to_json', True):
+                if dotty_info.get(info_key) and info_dict.get('warn_duplicate', True):
+                    _log_warning(info_data, '%s in config.h is overwriting %s in info.json' % (config_key, info_key))
+
+                dotty_info[info_key] = _config_to_json(key_type, config_c[config_key])
+
+        except Exception as e:
+            _log_warning(info_data, f'{config_key}->{info_key}: {e}')
+
+    info_data.update(dotty_info)
+
+    # Pull data that easily can't be mapped in json
+    _extract_matrix_info(info_data, config_c)
+    _extract_audio(info_data, config_c)
+    _extract_secure_unlock(info_data, config_c)
+    _extract_split_handedness(info_data, config_c)
+    _extract_split_serial(info_data, config_c)
+    _extract_split_transport(info_data, config_c)
+    _extract_split_right_pins(info_data, config_c)
+    _extract_encoders(info_data, config_c)
+    _extract_split_encoders(info_data, config_c)
+
+    return info_data
+
+
+def _process_defaults(info_data):
+    """Process any additional defaults based on currently discovered information
+    """
+    defaults_map = json_load(Path('data/mappings/defaults.hjson'))
+    for default_type in defaults_map.keys():
+        thing_map = defaults_map[default_type]
+        if default_type in info_data:
+            merged_count = 0
+            thing_items = thing_map.get(info_data[default_type], {}).items()
+            for key, value in thing_items:
+                if key not in info_data:
+                    info_data[key] = value
+                    merged_count += 1
+
+            if merged_count == 0 and len(thing_items) > 0:
+                _log_warning(info_data, 'All defaults for \'%s\' were skipped, potential redundant config or misconfiguration detected' % (default_type))
+
+    return info_data
+
+
+def _extract_rules_mk(info_data, rules):
+    """Pull some keyboard information from existing rules.mk files
+    """
+    info_data['processor'] = rules.get('MCU', info_data.get('processor', 'atmega32u4'))
+
+    if info_data['processor'] in CHIBIOS_PROCESSORS:
+        arm_processor_rules(info_data, rules)
+
+    elif info_data['processor'] in LUFA_PROCESSORS + VUSB_PROCESSORS:
+        avr_processor_rules(info_data, rules)
+
+    else:
+        cli.log.warning("%s: Unknown MCU: %s" % (info_data['keyboard_folder'], info_data['processor']))
+        unknown_processor_rules(info_data, rules)
+
+    # Pull in data from the json map
+    dotty_info = dotty(info_data)
+    info_rules_map = json_load(Path('data/mappings/info_rules.hjson'))
+
+    for rules_key, info_dict in info_rules_map.items():
+        info_key = info_dict['info_key']
+        key_type = info_dict.get('value_type', 'raw')
+
+        try:
+            replace_with = info_dict.get('replace_with')
+            if rules_key in rules and info_dict.get('invalid', False):
+                if replace_with:
+                    _log_error(info_data, '%s in rules.mk is no longer a valid option and should be replaced with %s' % (rules_key, replace_with))
+                else:
+                    _log_error(info_data, '%s in rules.mk is no longer a valid option and should be removed' % rules_key)
+            elif rules_key in rules and info_dict.get('deprecated', False):
+                if replace_with:
+                    _log_warning(info_data, '%s in rules.mk is deprecated in favor of %s and will be removed at a later date' % (rules_key, replace_with))
+                else:
+                    _log_warning(info_data, '%s in rules.mk is deprecated and will be removed at a later date' % rules_key)
+
+            if rules_key in rules and info_dict.get('to_json', True):
+                if dotty_info.get(info_key) and info_dict.get('warn_duplicate', True):
+                    _log_warning(info_data, '%s in rules.mk is overwriting %s in info.json' % (rules_key, info_key))
+
+                dotty_info[info_key] = _config_to_json(key_type, rules[rules_key])
+
+        except Exception as e:
+            _log_warning(info_data, f'{rules_key}->{info_key}: {e}')
+
+    info_data.update(dotty_info)
+
+    # Merge in config values that can't be easily mapped
+    _extract_features(info_data, rules)
+    _extract_matrix_rules(info_data, rules)
+
+    return info_data
+
+
+def find_keyboard_c(keyboard):
+    """Find all <keyboard>.c files
+    """
+    keyboard = Path(keyboard)
+    current_path = Path('keyboards/')
+
+    files = []
+    for directory in keyboard.parts:
+        current_path = current_path / directory
+        keyboard_c_path = current_path / f'{directory}.c'
+        if keyboard_c_path.exists():
+            files.append(keyboard_c_path)
+
+    return files
+
+
+def _extract_led_config(info_data, keyboard):
+    """Scan all <keyboard>.c files for led config
+    """
+    for feature in ['rgb_matrix', 'led_matrix']:
+        if info_data.get('features', {}).get(feature, False) or feature in info_data:
+            # Only attempt search if dd led config is missing
+            if 'layout' not in info_data.get(feature, {}):
+                cols = info_data.get('matrix_size', {}).get('cols')
+                rows = info_data.get('matrix_size', {}).get('rows')
+                if cols and rows:
+                    # Process
+                    for file in find_keyboard_c(keyboard):
+                        try:
+                            ret = find_led_config(file, cols, rows)
+                            if ret:
+                                info_data[feature] = info_data.get(feature, {})
+                                info_data[feature]['layout'] = ret
+                        except Exception as e:
+                            _log_warning(info_data, f'led_config: {file.name}: {e}')
+                else:
+                    _log_warning(info_data, 'led_config: matrix size required to parse g_led_config')
+
+            if info_data[feature].get('layout', None) and not info_data[feature].get('led_count', None):
+                info_data[feature]['led_count'] = len(info_data[feature]['layout'])
+
+            if info_data[feature].get('layout', None) and not info_data[feature].get('flag_steps', None):
+                flags = {LedFlags.ALL, LedFlags.NONE}
+                default_flags = {LedFlags.MODIFIER | LedFlags.KEYLIGHT, LedFlags.UNDERGLOW}
+
+                # if only a single flag is used, assume only all+none flags
+                kb_flags = set(x.get('flags', LedFlags.NONE) for x in info_data[feature]['layout'])
+                if len(kb_flags) > 1:
+                    # check if any part of LED flag is with the defaults
+                    unique_flags = set()
+                    for candidate in default_flags:
+                        if any(candidate & flag for flag in kb_flags):
+                            unique_flags.add(candidate)
+
+                    # if we still have a single flag, assume only all+none
+                    if len(unique_flags) > 1:
+                        flags.update(unique_flags)
+
+                info_data[feature]['flag_steps'] = sorted([int(flag) for flag in flags], reverse=True)
+
+    return info_data
+
+
+def _matrix_size(info_data):
+    """Add info_data['matrix_size'] if it doesn't exist.
+    """
+    if 'matrix_size' not in info_data and 'matrix_pins' in info_data:
+        info_data['matrix_size'] = {}
+
+        if 'direct' in info_data['matrix_pins']:
+            info_data['matrix_size']['cols'] = len(info_data['matrix_pins']['direct'][0])
+            info_data['matrix_size']['rows'] = len(info_data['matrix_pins']['direct'])
+        elif 'cols' in info_data['matrix_pins'] and 'rows' in info_data['matrix_pins']:
+            info_data['matrix_size']['cols'] = len(info_data['matrix_pins']['cols'])
+            info_data['matrix_size']['rows'] = len(info_data['matrix_pins']['rows'])
+
+        # Assumption of split common
+        if 'split' in info_data:
+            if info_data['split'].get('enabled', False):
+                info_data['matrix_size']['rows'] *= 2
+
+    return info_data
+
+
+def _joystick_axis_count(info_data):
+    """Add info_data['joystick.axis_count'] if required
+    """
+    if 'axes' in info_data.get('joystick', {}):
+        axes_keys = info_data['joystick']['axes'].keys()
+        info_data['joystick']['axis_count'] = max(JOYSTICK_AXES.index(a) for a in axes_keys) + 1 if axes_keys else 0
+
+    return info_data
+
+
+def _matrix_masked(info_data):
+    """"Add info_data['matrix_pins.masked'] if required"""
+    mask_required = False
+
+    if 'matrix_grid' in info_data.get('dip_switch', {}):
+        mask_required = True
+    if 'matrix_grid' in info_data.get('split', {}).get('handedness', {}):
+        mask_required = True
+
+    if mask_required:
+        if 'masked' not in info_data.get('matrix_pins', {}):
+            if 'matrix_pins' not in info_data:
+                info_data['matrix_pins'] = {}
+
+            info_data['matrix_pins']['masked'] = True
+
+    return info_data
+
+
+def _check_matrix(info_data):
+    """Check the matrix to ensure that row/column count is consistent.
+    """
+    if 'matrix_pins' in info_data and 'matrix_size' in info_data:
+        actual_col_count = info_data['matrix_size'].get('cols', 0)
+        actual_row_count = info_data['matrix_size'].get('rows', 0)
+        col_count = row_count = 0
+
+        if 'direct' in info_data['matrix_pins']:
+            col_count = len(info_data['matrix_pins']['direct'][0])
+            row_count = len(info_data['matrix_pins']['direct'])
+        elif 'cols' in info_data['matrix_pins'] and 'rows' in info_data['matrix_pins']:
+            col_count = len(info_data['matrix_pins']['cols'])
+            row_count = len(info_data['matrix_pins']['rows'])
+        elif 'cols' not in info_data['matrix_pins'] and 'rows' not in info_data['matrix_pins']:
+            # This case caters for custom matrix implementations where normal rows/cols are specified
+            return
+
+        if col_count != actual_col_count and col_count != (actual_col_count / 2):
+            # FIXME: once we can we should detect if split is enabled to do the actual_col_count/2 check.
+            _log_error(info_data, f'MATRIX_COLS is inconsistent with the size of MATRIX_COL_PINS: {col_count} != {actual_col_count}')
+
+        if row_count != actual_row_count and row_count != (actual_row_count / 2):
+            # FIXME: once we can we should detect if split is enabled to do the actual_row_count/2 check.
+            _log_error(info_data, f'MATRIX_ROWS is inconsistent with the size of MATRIX_ROW_PINS: {row_count} != {actual_row_count}')
+
+
+def _search_keyboard_h(keyboard):
+    keyboard = Path(keyboard)
+    current_path = Path('keyboards/')
+    aliases = {}
+    layouts = {}
+
+    for directory in keyboard.parts:
+        current_path = current_path / directory
+        keyboard_h = '%s.h' % (directory,)
+        keyboard_h_path = current_path / keyboard_h
+        if keyboard_h_path.exists():
+            new_layouts, new_aliases = find_layouts(keyboard_h_path)
+            layouts.update(new_layouts)
+
+            for alias, alias_text in new_aliases.items():
+                if alias_text in layouts:
+                    aliases[alias] = alias_text
+
+    return layouts, aliases
+
+
+def _log_error(info_data, message):
+    """Send an error message to both JSON and the log.
+    """
+    info_data['parse_errors'].append(message)
+    cli.log.error('%s: %s', info_data.get('keyboard_folder', 'Unknown Keyboard!'), message)
+
+
+def _log_warning(info_data, message):
+    """Send a warning message to both JSON and the log.
+    """
+    info_data['parse_warnings'].append(message)
+    cli.log.warning('%s: %s', info_data.get('keyboard_folder', 'Unknown Keyboard!'), message)
+
+
+def arm_processor_rules(info_data, rules):
+    """Setup the default info for an ARM board.
+    """
+    info_data['processor_type'] = 'arm'
+    info_data['protocol'] = 'ChibiOS'
+    info_data['platform_key'] = 'chibios'
+
+    if 'STM32' in info_data['processor']:
+        info_data['platform'] = 'STM32'
+    elif 'MCU_SERIES' in rules:
+        info_data['platform'] = rules['MCU_SERIES']
+
+    return info_data
+
+
+def avr_processor_rules(info_data, rules):
+    """Setup the default info for an AVR board.
+    """
+    info_data['processor_type'] = 'avr'
+    info_data['platform'] = rules['ARCH'] if 'ARCH' in rules else 'unknown'
+    info_data['platform_key'] = 'avr'
+    info_data['protocol'] = 'V-USB' if info_data['processor'] in VUSB_PROCESSORS else 'LUFA'
+
+    # FIXME(fauxpark/anyone): Eventually we should detect the protocol by looking at PROTOCOL inherited from mcu_selection.mk:
+    # info_data['protocol'] = 'V-USB' if rules.get('PROTOCOL') == 'VUSB' else 'LUFA'
+
+    return info_data
+
+
+def unknown_processor_rules(info_data, rules):
+    """Setup the default keyboard info for unknown boards.
+    """
+    info_data['bootloader'] = 'unknown'
+    info_data['platform'] = 'unknown'
+    info_data['processor'] = 'unknown'
+    info_data['processor_type'] = 'unknown'
+    info_data['protocol'] = 'unknown'
+
+    return info_data
+
+
+def merge_info_jsons(keyboard, info_data):
+    """Return a merged copy of all the info.json files for a keyboard.
+    """
+    config_files = find_info_json(keyboard)
+
+    for info_file in config_files:
+        # Load and validate the JSON data
+        new_info_data = json_load(info_file)
+
+        if not isinstance(new_info_data, dict):
+            _log_error(info_data, "Invalid file %s, root object should be a dictionary." % (str(info_file),))
+            continue
+
+        if not truthy(os.environ.get('SKIP_SCHEMA_VALIDATION'), False):
+            try:
+                validate(new_info_data, 'qmk.keyboard.v1')
+            except jsonschema.ValidationError as e:
+                json_path = '.'.join([str(p) for p in e.absolute_path])
+                cli.log.error('Not including data from file: %s', info_file)
+                cli.log.error('\t%s: %s', json_path, e.message)
+                continue
+
+        # Merge layout data in
+        if 'layout_aliases' in new_info_data:
+            info_data['layout_aliases'] = {**info_data.get('layout_aliases', {}), **new_info_data['layout_aliases']}
+            del new_info_data['layout_aliases']
+
+        for layout_name, layout in new_info_data.get('layouts', {}).items():
+            if layout_name in info_data.get('layout_aliases', {}):
+                _log_warning(info_data, f"info.json uses alias name {layout_name} instead of {info_data['layout_aliases'][layout_name]}")
+                layout_name = info_data['layout_aliases'][layout_name]
+
+            if layout_name in info_data['layouts']:
+                if len(info_data['layouts'][layout_name]['layout']) != len(layout['layout']):
+                    msg = 'Number of keys for %s does not match! info.json specifies %d keys, C macro specifies %d'
+                    _log_error(info_data, msg % (layout_name, len(layout['layout']), len(info_data['layouts'][layout_name]['layout'])))
+                else:
+                    info_data['layouts'][layout_name]['json_layout'] = True
+                    for new_key, existing_key in zip(layout['layout'], info_data['layouts'][layout_name]['layout']):
+                        existing_key.update(new_key)
+            else:
+                if not all('matrix' in key_data.keys() for key_data in layout['layout']):
+                    _log_error(info_data, f'Layout "{layout_name}" has no "matrix" definition in either "info.json" or "<keyboard>.h"!')
+                else:
+                    layout['c_macro'] = False
+                    layout['json_layout'] = True
+                    info_data['layouts'][layout_name] = layout
+
+        # Update info_data with the new data
+        if 'layouts' in new_info_data:
+            del new_info_data['layouts']
+
+        deep_update(info_data, new_info_data)
+
+    return info_data
+
+
+def find_info_json(keyboard):
+    """Finds all the info.json files associated with a keyboard.
+    """
+    # Find the most specific first
+    base_path = Path('keyboards')
+    keyboard_path = base_path / keyboard
+    keyboard_parent = keyboard_path.parent
+    info_jsons = [keyboard_path / 'info.json', keyboard_path / 'keyboard.json']
+
+    # Add in parent folders for least specific
+    for _ in range(5):
+        if keyboard_parent == base_path:
+            break
+        info_jsons.append(keyboard_parent / 'info.json')
+        info_jsons.append(keyboard_parent / 'keyboard.json')
+        keyboard_parent = keyboard_parent.parent
+
+    # Return a list of the info.json files that actually exist
+    return [info_json for info_json in info_jsons if info_json.exists()]
+
+
+def keymap_json_config(keyboard, keymap, force_layout=None):
+    """Extract keymap level config
+    """
+    # TODO: resolve keymap.py and info.py circular dependencies
+    from qmk.keymap import locate_keymap
+
+    keymap_folder = locate_keymap(keyboard, keymap, force_layout=force_layout).parent
+
+    km_info_json = parse_configurator_json(keymap_folder / 'keymap.json')
+    return km_info_json.get('config', {})
+
+
+def keymap_json(keyboard, keymap, force_layout=None):
+    """Generate the info.json data for a specific keymap.
+    """
+    # TODO: resolve keymap.py and info.py circular dependencies
+    from qmk.keymap import locate_keymap
+
+    keymap_folder = locate_keymap(keyboard, keymap, force_layout=force_layout).parent
+
+    # Files to scan
+    keymap_config = keymap_folder / 'config.h'
+    keymap_rules = keymap_folder / 'rules.mk'
+    keymap_file = keymap_folder / 'keymap.json'
+
+    # Build the info.json file
+    kb_info_json = info_json(keyboard, force_layout=force_layout)
+
+    # Merge in the data from keymap.json
+    km_info_json = keymap_json_config(keyboard, keymap, force_layout=force_layout) if keymap_file.exists() else {}
+    deep_update(kb_info_json, km_info_json)
+
+    # Merge in the data from config.h, and rules.mk
+    _extract_rules_mk(kb_info_json, parse_rules_mk_file(keymap_rules))
+    _extract_config_h(kb_info_json, parse_config_h_file(keymap_config))
+
+    return kb_info_json
+
+
+def get_modules(keyboard, keymap_filename):
+    """Get the modules for a keyboard/keymap.
+    """
+    modules = []
+
+    kb_info_json = info_json(keyboard)
+    modules.extend(kb_info_json.get('modules', []))
+
+    if keymap_filename:
+        keymap_json = parse_configurator_json(keymap_filename)
+
+        if keymap_json:
+            modules.extend(keymap_json.get('modules', []))
+
+    return list(dict.fromkeys(modules))  # remove dupes
diff --git a/lib/python/qmk/json_encoders.py b/lib/python/qmk/json_encoders.py
new file mode 100755
index 0000000000..6bad820a76
--- /dev/null
+++ b/lib/python/qmk/json_encoders.py
@@ -0,0 +1,267 @@
+"""Class that pretty-prints QMK info.json files.
+"""
+import json
+from decimal import Decimal
+
+newline = '\n'
+
+
+class QMKJSONEncoder(json.JSONEncoder):
+    """Base class for all QMK JSON encoders.
+    """
+    container_types = (list, tuple, dict)
+    indentation_char = " "
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.indentation_level = 0
+
+        if not self.indent:
+            self.indent = 4
+
+    def encode_decimal(self, obj):
+        """Encode a decimal object.
+        """
+        if obj == int(obj):  # I can't believe Decimal objects don't have .is_integer()
+            return int(obj)
+
+        return float(obj)
+
+    def encode_dict(self, obj, path):
+        """Encode a dict-like object.
+        """
+        if obj:
+            self.indentation_level += 1
+
+            items = sorted(obj.items(), key=self.sort_dict) if self.sort_keys else obj.items()
+            output = [self.indent_str + f"{json.dumps(key)}: {self.encode(value, path + [key])}" for key, value in items]
+
+            self.indentation_level -= 1
+
+            return "{\n" + ",\n".join(output) + "\n" + self.indent_str + "}"
+        else:
+            return "{}"
+
+    def encode_dict_single_line(self, obj, path):
+        """Encode a dict-like object onto a single line.
+        """
+        return "{" + ", ".join(f"{json.dumps(key)}: {self.encode(value, path + [key])}" for key, value in sorted(obj.items(), key=self.sort_layout)) + "}"
+
+    def encode_list(self, obj, path):
+        """Encode a list-like object.
+        """
+        if self.primitives_only(obj):
+            return "[" + ", ".join(self.encode(value, path + [index]) for index, value in enumerate(obj)) + "]"
+
+        else:
+            self.indentation_level += 1
+
+            if path[-1] in ('layout', 'rotary'):
+                # These are part of a LED layout or encoder config, put them on a single line
+                output = [self.indent_str + self.encode_dict_single_line(value, path + [index]) for index, value in enumerate(obj)]
+            else:
+                output = [self.indent_str + self.encode(value, path + [index]) for index, value in enumerate(obj)]
+
+            self.indentation_level -= 1
+
+            return "[\n" + ",\n".join(output) + "\n" + self.indent_str + "]"
+
+    def encode(self, obj, path=[]):
+        """Encode JSON objects for QMK.
+        """
+        if isinstance(obj, Decimal):
+            return self.encode_decimal(obj)
+
+        elif isinstance(obj, (list, tuple)):
+            return self.encode_list(obj, path)
+
+        elif isinstance(obj, dict):
+            return self.encode_dict(obj, path)
+
+        else:
+            return super().encode(obj)
+
+    def primitives_only(self, obj):
+        """Returns true if the object doesn't have any container type objects (list, tuple, dict).
+        """
+        if isinstance(obj, dict):
+            obj = obj.values()
+
+        return not any(isinstance(element, self.container_types) for element in obj)
+
+    @property
+    def indent_str(self):
+        return self.indentation_char * (self.indentation_level * self.indent)
+
+
+class InfoJSONEncoder(QMKJSONEncoder):
+    """Custom encoder to make info.json's a little nicer to work with.
+    """
+    def sort_layout(self, item):
+        """Sorts the hashes in a nice way.
+        """
+        key = item[0]
+
+        if key == 'label':
+            return '00label'
+
+        elif key == 'matrix':
+            return '01matrix'
+
+        elif key == 'x':
+            return '02x'
+
+        elif key == 'y':
+            return '03y'
+
+        elif key == 'w':
+            return '04w'
+
+        elif key == 'h':
+            return '05h'
+
+        elif key == 'flags':
+            return '06flags'
+
+        return key
+
+    def sort_dict(self, item):
+        """Forces layout to the back of the sort order.
+        """
+        key = item[0]
+
+        if self.indentation_level == 1:
+            if key == 'manufacturer':
+                return '10manufacturer'
+
+            elif key == 'keyboard_name':
+                return '11keyboard_name'
+
+            elif key == 'maintainer':
+                return '12maintainer'
+
+            elif key == 'community_layouts':
+                return '97community_layouts'
+
+            elif key == 'layout_aliases':
+                return '98layout_aliases'
+
+            elif key == 'layouts':
+                return '99layouts'
+
+            else:
+                return '50' + str(key)
+
+        return key
+
+
+class KeymapJSONEncoder(QMKJSONEncoder):
+    """Custom encoder to make keymap.json's a little nicer to work with.
+    """
+    def encode_list(self, obj, path):
+        """Encode a list-like object.
+        """
+        if self.indentation_level == 2:
+            indent_level = self.indentation_level + 1
+            # We have a list of keycodes
+            layer = [[]]
+
+            for key in obj:
+                if key == 'JSON_NEWLINE':
+                    layer.append([])
+                else:
+                    if isinstance(key, dict):
+                        # We have a macro
+
+                        # TODO: Add proper support for nicely formatting keymap.json macros
+                        layer[-1].append(f'{self.encode(key)}')
+                    else:
+                        layer[-1].append(f'"{key}"')
+
+            layer = [f"{self.indent_str * indent_level}{', '.join(row)}" for row in layer]
+
+            return f"{self.indent_str}[\n{newline.join(layer)}\n{self.indent_str * self.indentation_level}]"
+
+        elif self.primitives_only(obj):
+            return "[" + ", ".join(self.encode(element) for element in obj) + "]"
+
+        else:
+            self.indentation_level += 1
+            output = [self.indent_str + self.encode(element) for element in obj]
+            self.indentation_level -= 1
+
+            return "[\n" + ",\n".join(output) + "\n" + self.indent_str + "]"
+
+    def sort_dict(self, item):
+        """Sorts the hashes in a nice way.
+        """
+        key = item[0]
+
+        if self.indentation_level == 1:
+            if key == 'version':
+                return '00version'
+
+            elif key == 'author':
+                return '01author'
+
+            elif key == 'notes':
+                return '02notes'
+
+            elif key == 'layers':
+                return '98layers'
+
+            elif key == 'documentation':
+                return '99documentation'
+
+            else:
+                return '50' + str(key)
+
+        return key
+
+
+class UserspaceJSONEncoder(QMKJSONEncoder):
+    """Custom encoder to make userspace qmk.json's a little nicer to work with.
+    """
+    def sort_dict(self, item):
+        """Sorts the hashes in a nice way.
+        """
+        key = item[0]
+
+        if self.indentation_level == 1:
+            if key == 'userspace_version':
+                return '00userspace_version'
+
+            if key == 'build_targets':
+                return '01build_targets'
+
+        return key
+
+
+class CommunityModuleJSONEncoder(QMKJSONEncoder):
+    """Custom encoder to make qmk_module.json's a little nicer to work with.
+    """
+    def sort_dict(self, item):
+        """Sorts the hashes in a nice way.
+        """
+        key = item[0]
+
+        if self.indentation_level == 1:
+            if key == 'module_name':
+                return '00module_name'
+            if key == 'maintainer':
+                return '01maintainer'
+            if key == 'license':
+                return '02license'
+            if key == 'url':
+                return '03url'
+            if key == 'features':
+                return '04features'
+            if key == 'keycodes':
+                return '05keycodes'
+        elif self.indentation_level == 3:  # keycodes
+            if key == 'key':
+                return '00key'
+            if key == 'aliases':
+                return '01aliases'
+
+        return key
diff --git a/lib/python/qmk/json_schema.py b/lib/python/qmk/json_schema.py
new file mode 100644
index 0000000000..e871598565
--- /dev/null
+++ b/lib/python/qmk/json_schema.py
@@ -0,0 +1,151 @@
+"""Functions that help us generate and use info.json files.
+"""
+import json
+import hjson
+import jsonschema
+from collections.abc import Mapping
+from functools import lru_cache
+from typing import OrderedDict
+from pathlib import Path
+from copy import deepcopy
+
+from milc import cli
+
+from qmk.util import maybe_exit
+
+
+def _dict_raise_on_duplicates(ordered_pairs):
+    """Reject duplicate keys."""
+    d = {}
+    for k, v in ordered_pairs:
+        if k in d:
+            raise ValueError("duplicate key: %r" % (k,))
+        else:
+            d[k] = v
+    return d
+
+
+@lru_cache(maxsize=20)
+def _json_load_impl(json_file, strict=True):
+    """Load a json file from disk.
+
+    Note: file must be a Path object.
+    """
+    try:
+        # Get the IO Stream for Path objects
+        # Not necessary if the data is provided via stdin
+        if isinstance(json_file, Path):
+            json_file = json_file.open(encoding='utf-8')
+        return hjson.load(json_file, object_pairs_hook=_dict_raise_on_duplicates if strict else None)
+
+    except (json.decoder.JSONDecodeError, hjson.HjsonDecodeError) as e:
+        cli.log.error('Invalid JSON encountered attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e)
+        maybe_exit(1)
+    except Exception as e:
+        cli.log.error('Unknown error attempting to load {fg_cyan}%s{fg_reset}:\n\t{fg_red}%s', json_file, e)
+        maybe_exit(1)
+
+
+def json_load(json_file, strict=True):
+    return deepcopy(_json_load_impl(json_file=json_file, strict=strict))
+
+
+@lru_cache(maxsize=20)
+def load_jsonschema(schema_name):
+    """Read a jsonschema file from disk.
+    """
+    if Path(schema_name).exists():
+        return json_load(schema_name)
+
+    schema_path = Path(f'data/schemas/{schema_name}.jsonschema')
+
+    if not schema_path.exists():
+        schema_path = Path('data/schemas/false.jsonschema')
+
+    return json_load(schema_path)
+
+
+@lru_cache(maxsize=1)
+def compile_schema_store():
+    """Compile all our schemas into a schema store.
+    """
+    schema_store = {}
+
+    for schema_file in Path('data/schemas').glob('*.jsonschema'):
+        schema_data = load_jsonschema(schema_file)
+        if not isinstance(schema_data, dict):
+            cli.log.debug('Skipping schema file %s', schema_file)
+            continue
+
+        # `$id`-based references
+        schema_store[schema_data['$id']] = schema_data
+
+        # Path-based references
+        schema_store[Path(schema_file).name] = schema_data
+
+    return schema_store
+
+
+@lru_cache(maxsize=20)
+def create_validator(schema):
+    """Creates a validator for the given schema id.
+    """
+    schema_store = compile_schema_store()
+    resolver = jsonschema.RefResolver.from_schema(schema_store[schema], store=schema_store)
+
+    return jsonschema.Draft202012Validator(schema_store[schema], resolver=resolver).validate
+
+
+def validate(data, schema):
+    """Validates data against a schema.
+    """
+    validator = create_validator(schema)
+
+    return validator(data)
+
+
+def deep_update(origdict, newdict):
+    """Update a dictionary in place, recursing to do a depth-first deep copy.
+    """
+    for key, value in newdict.items():
+        if isinstance(value, Mapping):
+            origdict[key] = deep_update(origdict.get(key, {}), value)
+
+        else:
+            origdict[key] = value
+
+    return origdict
+
+
+def merge_ordered_dicts(dicts):
+    """Merges nested OrderedDict objects resulting from reading a hjson file.
+    Later input dicts overrides earlier dicts for plain values.
+    If any value is "!delete!", the existing value will be removed from its parent.
+    Arrays will be appended. If the first entry of an array is "!reset!", the contents of the array will be cleared and replaced with RHS.
+    Dictionaries will be recursively merged. If any entry is "!reset!", the contents of the dictionary will be cleared and replaced with RHS.
+    """
+    result = OrderedDict()
+
+    def add_entry(target, k, v):
+        if k in target and isinstance(v, (OrderedDict, dict)):
+            if "!reset!" in v:
+                target[k] = v
+            else:
+                target[k] = merge_ordered_dicts([target[k], v])
+            if "!reset!" in target[k]:
+                del target[k]["!reset!"]
+        elif k in target and isinstance(v, list):
+            if v[0] == '!reset!':
+                target[k] = v[1:]
+            else:
+                target[k] = target[k] + v
+        elif v == "!delete!" and isinstance(target, (OrderedDict, dict)):
+            del target[k]
+        else:
+            target[k] = v
+
+    for d in dicts:
+        for (k, v) in d.items():
+            add_entry(result, k, v)
+
+    return result
diff --git a/lib/python/qmk/keyboard.py b/lib/python/qmk/keyboard.py
new file mode 100644
index 0000000000..e8534492c9
--- /dev/null
+++ b/lib/python/qmk/keyboard.py
@@ -0,0 +1,401 @@
+"""Functions that help us work with keyboards.
+"""
+from array import array
+from functools import lru_cache
+from math import ceil
+from pathlib import Path
+import os
+from glob import glob
+
+import qmk.path
+from qmk.c_parse import parse_config_h_file
+from qmk.json_schema import json_load
+from qmk.makefile import parse_rules_mk_file
+
+BOX_DRAWING_CHARACTERS = {
+    "unicode": {
+        "tl": "┌",
+        "tr": "┐",
+        "bl": "└",
+        "br": "┘",
+        "v": "│",
+        "h": "─",
+    },
+    "ascii": {
+        "tl": " ",
+        "tr": " ",
+        "bl": "|",
+        "br": "|",
+        "v": "|",
+        "h": "_",
+    },
+}
+ENC_DRAWING_CHARACTERS = {
+    "unicode": {
+        "tl": "╭",
+        "tr": "╮",
+        "bl": "╰",
+        "br": "╯",
+        "vl": "▲",
+        "vr": "▼",
+        "v": "│",
+        "h": "─",
+    },
+    "ascii": {
+        "tl": " ",
+        "tr": " ",
+        "bl": "\\",
+        "br": "/",
+        "v": "|",
+        "vl": "/",
+        "vr": "\\",
+        "h": "_",
+    },
+}
+
+
+class AllKeyboards:
+    """Represents all keyboards.
+    """
+    def __str__(self):
+        return 'all'
+
+    def __repr__(self):
+        return 'all'
+
+    def __eq__(self, other):
+        return isinstance(other, AllKeyboards)
+
+
+base_path = os.path.join(os.getcwd(), "keyboards") + os.path.sep
+
+
+@lru_cache(maxsize=1)
+def keyboard_alias_definitions():
+    return json_load(Path('data/mappings/keyboard_aliases.hjson'))
+
+
+def is_all_keyboards(keyboard):
+    """Returns True if the keyboard is an AllKeyboards object.
+    """
+    if isinstance(keyboard, str):
+        return (keyboard == 'all')
+    return isinstance(keyboard, AllKeyboards)
+
+
+def find_keyboard_from_dir():
+    """Returns a keyboard name based on the user's current directory.
+    """
+    relative_cwd = qmk.path.under_qmk_userspace()
+    if not relative_cwd:
+        relative_cwd = qmk.path.under_qmk_firmware()
+
+    if relative_cwd and len(relative_cwd.parts) > 1 and relative_cwd.parts[0] == 'keyboards':
+        # Attempt to extract the keyboard name from the current directory
+        current_path = Path('/'.join(relative_cwd.parts[1:]))
+
+        if 'keymaps' in current_path.parts:
+            # Strip current_path of anything after `keymaps`
+            keymap_index = len(current_path.parts) - current_path.parts.index('keymaps') - 1
+            current_path = current_path.parents[keymap_index]
+
+        if qmk.path.is_keyboard(current_path):
+            return str(current_path)
+
+
+def find_readme(keyboard):
+    """Returns the readme for this keyboard.
+    """
+    cur_dir = qmk.path.keyboard(keyboard)
+    keyboards_dir = Path('keyboards')
+    while not (cur_dir / 'readme.md').exists():
+        if cur_dir == keyboards_dir:
+            return None
+        cur_dir = cur_dir.parent
+
+    return cur_dir / 'readme.md'
+
+
+def keyboard_folder(keyboard):
+    """Returns the actual keyboard folder.
+
+    This checks aliases to resolve the actual path for a keyboard.
+    """
+    aliases = keyboard_alias_definitions()
+
+    while keyboard in aliases:
+        last_keyboard = keyboard
+        keyboard = aliases[keyboard].get('target', keyboard)
+        if keyboard == last_keyboard:
+            break
+
+    if not qmk.path.is_keyboard(keyboard):
+        raise ValueError(f'Invalid keyboard: {keyboard}')
+
+    return keyboard
+
+
+def keyboard_aliases(keyboard):
+    """Returns the list of aliases for the supplied keyboard.
+
+    Includes the keyboard itself.
+    """
+    aliases = json_load(Path('data/mappings/keyboard_aliases.hjson'))
+
+    if keyboard in aliases:
+        keyboard = aliases[keyboard].get('target', keyboard)
+
+    keyboards = set(filter(lambda k: aliases[k].get('target', '') == keyboard, aliases.keys()))
+    keyboards.add(keyboard)
+    keyboards = list(sorted(keyboards))
+    return keyboards
+
+
+def keyboard_folder_or_all(keyboard):
+    """Returns the actual keyboard folder.
+
+    This checks aliases to resolve the actual path for a keyboard.
+    If the supplied argument is "all", it returns an AllKeyboards object.
+    """
+    if keyboard == 'all':
+        return AllKeyboards()
+
+    return keyboard_folder(keyboard)
+
+
+def _find_name(path):
+    """Determine the keyboard name by stripping off the base_path and filename.
+    """
+    return path.replace(base_path, "").rsplit(os.path.sep, 1)[0]
+
+
+def keyboard_completer(prefix, action, parser, parsed_args):
+    """Returns a list of keyboards for tab completion.
+    """
+    return list_keyboards()
+
+
+@lru_cache(maxsize=None)
+def list_keyboards():
+    """Returns a list of all keyboards.
+    """
+    # We avoid pathlib here because this is performance critical code.
+    kb_wildcard = os.path.join(base_path, "**", 'keyboard.json')
+    paths = [path for path in glob(kb_wildcard, recursive=True) if os.path.sep + 'keymaps' + os.path.sep not in path]
+
+    found = map(_find_name, paths)
+
+    # Convert to posix paths for consistency
+    found = map(lambda x: str(Path(x).as_posix()), found)
+
+    return sorted(set(found))
+
+
+def config_h(keyboard):
+    """Parses all the config.h files for a keyboard.
+
+    Args:
+        keyboard: name of the keyboard
+
+    Returns:
+        a dictionary representing the content of the entire config.h tree for a keyboard
+    """
+    config = {}
+    cur_dir = Path('keyboards')
+    keyboard = Path(keyboard)
+
+    for dir in keyboard.parts:
+        cur_dir = cur_dir / dir
+        config = {**config, **parse_config_h_file(cur_dir / 'config.h')}
+
+    return config
+
+
+def rules_mk(keyboard):
+    """Get a rules.mk for a keyboard
+
+    Args:
+        keyboard: name of the keyboard
+
+    Returns:
+        a dictionary representing the content of the entire rules.mk tree for a keyboard
+    """
+    cur_dir = Path('keyboards')
+    keyboard = Path(keyboard)
+    rules = parse_rules_mk_file(cur_dir / keyboard / 'rules.mk')
+
+    for i, dir in enumerate(keyboard.parts):
+        cur_dir = cur_dir / dir
+        rules = parse_rules_mk_file(cur_dir / 'rules.mk', rules)
+
+    return rules
+
+
+def render_layout(layout_data, render_ascii, key_labels=None):
+    """Renders a single layout.
+    """
+    textpad = [array('u', ' ' * 200) for x in range(100)]
+    style = 'ascii' if render_ascii else 'unicode'
+
+    for key in layout_data:
+        x = key.get('x', 0)
+        y = key.get('y', 0)
+        w = key.get('w', 1)
+        h = key.get('h', 1)
+
+        if key_labels:
+            label = key_labels.pop(0)
+            if label.startswith('KC_'):
+                label = label[3:]
+        else:
+            label = key.get('label', '')
+
+        if 'encoder' in key:
+            render_encoder(textpad, x, y, w, h, label, style)
+        elif x >= 0.25 and w == 1.25 and h == 2:
+            render_key_isoenter(textpad, x, y, w, h, label, style)
+        elif w == 1.5 and h == 2:
+            render_key_baenter(textpad, x, y, w, h, label, style)
+        else:
+            render_key_rect(textpad, x, y, w, h, label, style)
+
+    lines = []
+    for line in textpad:
+        if line.tounicode().strip():
+            lines.append(line.tounicode().rstrip())
+
+    return '\n'.join(lines)
+
+
+def render_layouts(info_json, render_ascii):
+    """Renders all the layouts from an `info_json` structure.
+    """
+    layouts = {}
+
+    for layout in info_json['layouts']:
+        layout_data = info_json['layouts'][layout]['layout']
+        layouts[layout] = render_layout(layout_data, render_ascii)
+
+    return layouts
+
+
+def render_key_rect(textpad, x, y, w, h, label, style):
+    box_chars = BOX_DRAWING_CHARACTERS[style]
+    x = ceil(x * 4)
+    y = ceil(y * 3)
+    w = ceil(w * 4)
+    h = ceil(h * 3)
+
+    label_len = w - 2
+    label_leftover = label_len - len(label)
+
+    if len(label) > label_len:
+        label = label[:label_len]
+
+    label_blank = ' ' * label_len
+    label_border = box_chars['h'] * label_len
+    label_middle = label + ' ' * label_leftover
+
+    top_line = array('u', box_chars['tl'] + label_border + box_chars['tr'])
+    lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
+    mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
+    bot_line = array('u', box_chars['bl'] + label_border + box_chars['br'])
+
+    textpad[y][x:x + w] = top_line
+    textpad[y + 1][x:x + w] = lab_line
+    for i in range(h - 3):
+        textpad[y + i + 2][x:x + w] = mid_line
+    textpad[y + h - 1][x:x + w] = bot_line
+
+
+def render_key_isoenter(textpad, x, y, w, h, label, style):
+    box_chars = BOX_DRAWING_CHARACTERS[style]
+    x = ceil(x * 4)
+    y = ceil(y * 3)
+    w = ceil(w * 4)
+    h = ceil(h * 3)
+
+    label_len = w - 1
+    label_leftover = label_len - len(label)
+
+    if len(label) > label_len:
+        label = label[:label_len]
+
+    label_blank = ' ' * (label_len - 1)
+    label_border_top = box_chars['h'] * label_len
+    label_border_bottom = box_chars['h'] * (label_len - 1)
+    label_middle = label + ' ' * label_leftover
+
+    top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr'])
+    lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
+    crn_line = array('u', box_chars['bl'] + box_chars['tr'] + label_blank + box_chars['v'])
+    mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
+    bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br'])
+
+    textpad[y][x - 1:x + w] = top_line
+    textpad[y + 1][x - 1:x + w] = lab_line
+    textpad[y + 2][x - 1:x + w] = crn_line
+    textpad[y + 3][x:x + w] = mid_line
+    textpad[y + 4][x:x + w] = mid_line
+    textpad[y + 5][x:x + w] = bot_line
+
+
+def render_key_baenter(textpad, x, y, w, h, label, style):
+    box_chars = BOX_DRAWING_CHARACTERS[style]
+    x = ceil(x * 4)
+    y = ceil(y * 3)
+    w = ceil(w * 4)
+    h = ceil(h * 3)
+
+    label_len = w + 1
+    label_leftover = label_len - len(label)
+
+    if len(label) > label_len:
+        label = label[:label_len]
+
+    label_blank = ' ' * (label_len - 3)
+    label_border_top = box_chars['h'] * (label_len - 3)
+    label_border_bottom = box_chars['h'] * label_len
+    label_middle = label + ' ' * label_leftover
+
+    top_line = array('u', box_chars['tl'] + label_border_top + box_chars['tr'])
+    mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
+    crn_line = array('u', box_chars['tl'] + box_chars['h'] + box_chars['h'] + box_chars['br'] + label_blank + box_chars['v'])
+    lab_line = array('u', box_chars['v'] + label_middle + box_chars['v'])
+    bot_line = array('u', box_chars['bl'] + label_border_bottom + box_chars['br'])
+
+    textpad[y][x:x + w] = top_line
+    textpad[y + 1][x:x + w] = mid_line
+    textpad[y + 2][x:x + w] = mid_line
+    textpad[y + 3][x - 3:x + w] = crn_line
+    textpad[y + 4][x - 3:x + w] = lab_line
+    textpad[y + 5][x - 3:x + w] = bot_line
+
+
+def render_encoder(textpad, x, y, w, h, label, style):
+    box_chars = ENC_DRAWING_CHARACTERS[style]
+    x = ceil(x * 4)
+    y = ceil(y * 3)
+    w = ceil(w * 4)
+    h = ceil(h * 3)
+
+    label_len = w - 2
+    label_leftover = label_len - len(label)
+
+    if len(label) > label_len:
+        label = label[:label_len]
+
+    label_blank = ' ' * label_len
+    label_border = box_chars['h'] * label_len
+    label_middle = label + ' ' * label_leftover
+
+    top_line = array('u', box_chars['tl'] + label_border + box_chars['tr'])
+    lab_line = array('u', box_chars['vl'] + label_middle + box_chars['vr'])
+    mid_line = array('u', box_chars['v'] + label_blank + box_chars['v'])
+    bot_line = array('u', box_chars['bl'] + label_border + box_chars['br'])
+
+    textpad[y][x:x + w] = top_line
+    textpad[y + 1][x:x + w] = lab_line
+    for i in range(h - 3):
+        textpad[y + i + 2][x:x + w] = mid_line
+    textpad[y + h - 1][x:x + w] = bot_line
diff --git a/lib/python/qmk/keycodes.py b/lib/python/qmk/keycodes.py
new file mode 100644
index 0000000000..9e4664e5f1
--- /dev/null
+++ b/lib/python/qmk/keycodes.py
@@ -0,0 +1,118 @@
+from pathlib import Path
+
+from qmk.json_schema import merge_ordered_dicts, deep_update, json_load, validate
+
+CONSTANTS_PATH = Path('data/constants/')
+KEYCODES_PATH = CONSTANTS_PATH / 'keycodes'
+EXTRAS_PATH = KEYCODES_PATH / 'extras'
+
+
+def _find_versions(path, prefix):
+    ret = []
+    for file in path.glob(f'{prefix}_[0-9].[0-9].[0-9].hjson'):
+        ret.append(file.stem.split('_')[-1])
+
+    ret.sort(reverse=True)
+    return ret
+
+
+def _potential_search_versions(version, lang=None):
+    versions = list_versions(lang)
+    versions.reverse()
+
+    loc = versions.index(version) + 1
+
+    return versions[:loc]
+
+
+def _search_path(lang=None):
+    return EXTRAS_PATH if lang else KEYCODES_PATH
+
+
+def _search_prefix(lang=None):
+    return f'keycodes_{lang}' if lang else 'keycodes'
+
+
+def _locate_files(path, prefix, versions):
+    # collate files by fragment "type"
+    files = {'_': []}
+    for version in versions:
+        files['_'].append(path / f'{prefix}_{version}.hjson')
+
+        for file in path.glob(f'{prefix}_{version}_*.hjson'):
+            fragment = file.stem.replace(f'{prefix}_{version}_', '')
+            if fragment not in files:
+                files[fragment] = []
+            files[fragment].append(file)
+
+    return files
+
+
+def _process_files(files):
+    # allow override within types of fragments - but not globally
+    spec = {}
+    for category in files.values():
+        specs = []
+        for file in category:
+            specs.append(json_load(file))
+
+        deep_update(spec, merge_ordered_dicts(specs))
+
+    return spec
+
+
+def _validate(spec):
+    # first throw it to the jsonschema
+    validate(spec, 'qmk.keycodes.v1')
+
+    # no duplicate keycodes
+    keycodes = []
+    for value in spec['keycodes'].values():
+        keycodes.append(value['key'])
+        keycodes.extend(value.get('aliases', []))
+    duplicates = set([x for x in keycodes if keycodes.count(x) > 1])
+    if duplicates:
+        raise ValueError(f'Keycode spec contains duplicate keycodes! ({",".join(duplicates)})')
+
+
+def load_spec(version, lang=None):
+    """Build keycode data from the requested spec file
+    """
+    if version == 'latest':
+        version = list_versions(lang)[0]
+
+    path = _search_path(lang)
+    prefix = _search_prefix(lang)
+    versions = _potential_search_versions(version, lang)
+
+    # Load bases + any fragments
+    spec = _process_files(_locate_files(path, prefix, versions))
+
+    # Sort?
+    spec['version'] = version
+    spec['keycodes'] = dict(sorted(spec.get('keycodes', {}).items()))
+    spec['ranges'] = dict(sorted(spec.get('ranges', {}).items()))
+
+    # Validate?
+    _validate(spec)
+
+    return spec
+
+
+def list_versions(lang=None):
+    """Return available versions - sorted newest first
+    """
+    path = _search_path(lang)
+    prefix = _search_prefix(lang)
+
+    return _find_versions(path, prefix)
+
+
+def list_languages():
+    """Return available languages
+    """
+    ret = set()
+    for file in EXTRAS_PATH.glob('keycodes_*_[0-9].[0-9].[0-9].hjson'):
+        ret.add(file.stem.split('_')[1])
+
+    return ret
diff --git a/lib/python/qmk/keymap.py b/lib/python/qmk/keymap.py
new file mode 100644
index 0000000000..0ac04f6f73
--- /dev/null
+++ b/lib/python/qmk/keymap.py
@@ -0,0 +1,681 @@
+"""Functions that help you work with QMK keymaps.
+"""
+import json
+import sys
+from pathlib import Path
+from subprocess import DEVNULL
+
+import argcomplete
+from milc import cli
+from pygments.lexers.c_cpp import CLexer
+from pygments.token import Token
+from pygments import lex
+
+import qmk.path
+from qmk.constants import QMK_FIRMWARE, QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.keyboard import find_keyboard_from_dir, keyboard_folder, keyboard_aliases
+from qmk.errors import CppError
+from qmk.info import info_json
+
+# The `keymap.c` template to use when a keyboard doesn't have its own
+DEFAULT_KEYMAP_C = """#include QMK_KEYBOARD_H
+#if __has_include("keymap.h")
+#    include "keymap.h"
+#endif
+__INCLUDES__
+
+/* THIS FILE WAS GENERATED!
+ *
+ * This file was generated by qmk json2c. You may or may not want to
+ * edit it directly.
+ */
+
+__KEYMAP_GOES_HERE__
+__ENCODER_MAP_GOES_HERE__
+__DIP_SWITCH_MAP_GOES_HERE__
+__MACRO_OUTPUT_GOES_HERE__
+
+#ifdef OTHER_KEYMAP_C
+#    include OTHER_KEYMAP_C
+#endif // OTHER_KEYMAP_C
+"""
+
+
+def _generate_keymap_table(keymap_json):
+    lines = ['const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {']
+    for layer_num, layer in enumerate(keymap_json['layers']):
+        if layer_num != 0:
+            lines[-1] = lines[-1] + ','
+        layer = map(_strip_any, layer)
+        layer_keys = ', '.join(layer)
+        lines.append('    [%s] = %s(%s)' % (layer_num, keymap_json['layout'], layer_keys))
+    lines.append('};')
+    return lines
+
+
+def _generate_encodermap_table(keymap_json):
+    lines = [
+        '#if defined(ENCODER_ENABLE) && defined(ENCODER_MAP_ENABLE)',
+        'const uint16_t PROGMEM encoder_map[][NUM_ENCODERS][NUM_DIRECTIONS] = {',
+    ]
+    for layer_num, layer in enumerate(keymap_json['encoders']):
+        if layer_num != 0:
+            lines[-1] = lines[-1] + ','
+        encoder_keycode_txt = ', '.join([f'ENCODER_CCW_CW({_strip_any(e["ccw"])}, {_strip_any(e["cw"])})' for e in layer])
+        lines.append('    [%s] = {%s}' % (layer_num, encoder_keycode_txt))
+    lines.extend(['};', '#endif // defined(ENCODER_ENABLE) && defined(ENCODER_MAP_ENABLE)'])
+    return lines
+
+
+def _generate_dipswitchmap_table(keymap_json):
+    lines = [
+        '#if defined(DIP_SWITCH_ENABLE) && defined(DIP_SWITCH_MAP_ENABLE)',
+        'const uint16_t PROGMEM dip_switch_map[NUM_DIP_SWITCHES][NUM_DIP_STATES] = {',
+    ]
+    for index, switch in enumerate(keymap_json['dip_switches']):
+        if index != 0:
+            lines[-1] = lines[-1] + ','
+        lines.append(f'    DIP_SWITCH_OFF_ON({_strip_any(switch["off"])}, {_strip_any(switch["on"])})')
+    lines.extend(['};', '#endif // defined(DIP_SWITCH_ENABLE) && defined(DIP_SWITCH_MAP_ENABLE)'])
+    return lines
+
+
+def _generate_macros_function(keymap_json):
+    macro_txt = [
+        'bool process_record_user(uint16_t keycode, keyrecord_t *record) {',
+        '    if (record->event.pressed) {',
+        '        switch (keycode) {',
+    ]
+
+    for i, macro_array in enumerate(keymap_json['macros']):
+        macro = []
+
+        for macro_fragment in macro_array:
+            if isinstance(macro_fragment, str):
+                macro_fragment = macro_fragment.replace('\\', '\\\\')
+                macro_fragment = macro_fragment.replace('\r\n', r'\n')
+                macro_fragment = macro_fragment.replace('\n', r'\n')
+                macro_fragment = macro_fragment.replace('\r', r'\n')
+                macro_fragment = macro_fragment.replace('\t', r'\t')
+                macro_fragment = macro_fragment.replace('"', r'\"')
+
+                macro.append(f'"{macro_fragment}"')
+
+            elif isinstance(macro_fragment, dict):
+                newstring = []
+
+                if macro_fragment['action'] == 'delay':
+                    newstring.append(f"SS_DELAY({macro_fragment['duration']})")
+
+                elif macro_fragment['action'] == 'beep':
+                    newstring.append(r'"\a"')
+
+                elif macro_fragment['action'] == 'tap' and len(macro_fragment['keycodes']) > 1:
+                    last_keycode = macro_fragment['keycodes'].pop()
+
+                    for keycode in macro_fragment['keycodes']:
+                        newstring.append(f'SS_DOWN(X_{keycode})')
+
+                    newstring.append(f'SS_TAP(X_{last_keycode})')
+
+                    for keycode in reversed(macro_fragment['keycodes']):
+                        newstring.append(f'SS_UP(X_{keycode})')
+
+                else:
+                    for keycode in macro_fragment['keycodes']:
+                        newstring.append(f"SS_{macro_fragment['action'].upper()}(X_{keycode})")
+
+                macro.append(''.join(newstring))
+
+        new_macro = "".join(macro)
+        new_macro = new_macro.replace('""', '')
+        macro_txt.append(f'            case QK_MACRO_{i}:')
+        macro_txt.append(f'                SEND_STRING({new_macro});')
+        macro_txt.append('                return false;')
+
+    macro_txt.append('        }')
+    macro_txt.append('    }')
+    macro_txt.append('\n    return true;')
+    macro_txt.append('};')
+    macro_txt.append('')
+    return macro_txt
+
+
+def _strip_any(keycode):
+    """Remove ANY() from a keycode.
+    """
+    if keycode.startswith('ANY(') and keycode.endswith(')'):
+        keycode = keycode[4:-1]
+
+    return keycode
+
+
+def find_keymap_from_dir(*args):
+    """Returns `(keymap_name, source)` for the directory provided (or cwd if not specified).
+    """
+    def _impl_find_keymap_from_dir(relative_path):
+        if relative_path and len(relative_path.parts) > 1:
+            # If we're in `qmk_firmware/keyboards` and `keymaps` is in our path, try to find the keyboard name.
+            if relative_path.parts[0] == 'keyboards' and 'keymaps' in relative_path.parts:
+                current_path = Path('/'.join(relative_path.parts[1:]))  # Strip 'keyboards' from the front
+
+                if 'keymaps' in current_path.parts and current_path.name != 'keymaps':
+                    while current_path.parent.name != 'keymaps':
+                        current_path = current_path.parent
+
+                    return current_path.name, 'keymap_directory'
+
+            # If we're in `qmk_firmware/layouts` guess the name from the community keymap they're in
+            elif relative_path.parts[0] == 'layouts' and is_keymap_dir(relative_path):
+                return relative_path.name, 'layouts_directory'
+
+            # If we're in `qmk_firmware/users` guess the name from the userspace they're in
+            elif relative_path.parts[0] == 'users':
+                # Guess the keymap name based on which userspace they're in
+                return relative_path.parts[1], 'users_directory'
+        return None, None
+
+    if HAS_QMK_USERSPACE:
+        name, source = _impl_find_keymap_from_dir(qmk.path.under_qmk_userspace(*args))
+        if name and source:
+            return name, source
+
+    name, source = _impl_find_keymap_from_dir(qmk.path.under_qmk_firmware(*args))
+    if name and source:
+        return name, source
+
+    return (None, None)
+
+
+def keymap_completer(prefix, action, parser, parsed_args):
+    """Returns a list of keymaps for tab completion.
+    """
+    try:
+        if parsed_args.keyboard:
+            return list_keymaps(parsed_args.keyboard)
+
+        keyboard = find_keyboard_from_dir()
+
+        if keyboard:
+            return list_keymaps(keyboard)
+
+    except Exception as e:
+        argcomplete.warn(f'Error: {e.__class__.__name__}: {str(e)}')
+        return []
+
+    return []
+
+
+def is_keymap_dir(keymap, c=True, json=True, additional_files=None):
+    """Return True if Path object `keymap` has a keymap file inside.
+
+    Args:
+        keymap
+            A Path() object for the keymap directory you want to check.
+
+        c
+            When true include `keymap.c` keymaps.
+
+        json
+            When true include `keymap.json` keymaps.
+
+        additional_files
+            A sequence of additional filenames to check against to determine if a directory is a keymap. All files must exist for a match to happen. For example, if you want to match a C keymap with both a `config.h` and `rules.mk` file: `is_keymap_dir(keymap_dir, json=False, additional_files=['config.h', 'rules.mk'])`
+    """
+    files = []
+
+    if c:
+        files.append('keymap.c')
+
+    if json:
+        files.append('keymap.json')
+
+    for file in files:
+        if (keymap / file).is_file():
+            if additional_files:
+                for additional_file in additional_files:
+                    if not (keymap / additional_file).is_file():
+                        return False
+
+            return True
+
+
+def generate_json(keymap, keyboard, layout, layers, macros=None):
+    """Returns a `keymap.json` for the specified keyboard, layout, and layers.
+
+    Args:
+        keymap
+            A name for this keymap.
+
+        keyboard
+            The name of the keyboard.
+
+        layout
+            The LAYOUT macro this keymap uses.
+
+        layers
+            An array of arrays describing the keymap. Each item in the inner array should be a string that is a valid QMK keycode.
+
+        macros
+            A sequence of strings containing macros to implement for this keyboard.
+    """
+    new_keymap = {'keyboard': keyboard}
+    new_keymap['keymap'] = keymap
+    new_keymap['layout'] = layout
+    new_keymap['layers'] = layers
+    if macros:
+        new_keymap['macros'] = macros
+
+    return new_keymap
+
+
+def generate_c(keymap_json):
+    """Returns a `keymap.c`.
+
+    `keymap_json` is a dictionary with the following keys:
+
+        keyboard
+            The name of the keyboard
+
+        layout
+            The LAYOUT macro this keymap uses.
+
+        layers
+            An array of arrays describing the keymap. Each item in the inner array should be a string that is a valid QMK keycode.
+
+        macros
+            A sequence of strings containing macros to implement for this keyboard.
+    """
+    new_keymap = DEFAULT_KEYMAP_C
+
+    keymap = ''
+    if 'layers' in keymap_json and keymap_json['layers'] is not None:
+        layer_txt = _generate_keymap_table(keymap_json)
+        keymap = '\n'.join(layer_txt)
+    new_keymap = new_keymap.replace('__KEYMAP_GOES_HERE__', keymap)
+
+    encodermap = ''
+    if 'encoders' in keymap_json and keymap_json['encoders'] is not None:
+        encoder_txt = _generate_encodermap_table(keymap_json)
+        encodermap = '\n'.join(encoder_txt)
+    new_keymap = new_keymap.replace('__ENCODER_MAP_GOES_HERE__', encodermap)
+
+    dipswitchmap = ''
+    if 'dip_switches' in keymap_json and keymap_json['dip_switches'] is not None:
+        dip_txt = _generate_dipswitchmap_table(keymap_json)
+        dipswitchmap = '\n'.join(dip_txt)
+    new_keymap = new_keymap.replace('__DIP_SWITCH_MAP_GOES_HERE__', dipswitchmap)
+
+    macros = ''
+    if 'macros' in keymap_json and keymap_json['macros'] is not None:
+        macro_txt = _generate_macros_function(keymap_json)
+        macros = '\n'.join(macro_txt)
+    new_keymap = new_keymap.replace('__MACRO_OUTPUT_GOES_HERE__', macros)
+
+    hostlang = ''
+    if 'host_language' in keymap_json and keymap_json['host_language'] is not None:
+        hostlang = f'#include "keymap_{keymap_json["host_language"]}.h"\n#include "sendstring_{keymap_json["host_language"]}.h"\n'
+    new_keymap = new_keymap.replace('__INCLUDES__', hostlang)
+
+    return new_keymap
+
+
+def write_file(keymap_filename, keymap_content):
+    keymap_filename.parent.mkdir(parents=True, exist_ok=True)
+    keymap_filename.write_text(keymap_content)
+
+    cli.log.info('Wrote keymap to {fg_cyan}%s', keymap_filename)
+
+    return keymap_filename
+
+
+def write_json(keyboard, keymap, layout, layers, macros=None):
+    """Generate the `keymap.json` and write it to disk.
+
+    Returns the filename written to.
+
+    Args:
+        keyboard
+            The name of the keyboard
+
+        keymap
+            The name of the keymap
+
+        layout
+            The LAYOUT macro this keymap uses.
+
+        layers
+            An array of arrays describing the keymap. Each item in the inner array should be a string that is a valid QMK keycode.
+    """
+    keymap_json = generate_json(keyboard, keymap, layout, layers, macros=None)
+    keymap_content = json.dumps(keymap_json)
+    keymap_file = qmk.path.keymaps(keyboard)[0] / keymap / 'keymap.json'
+
+    return write_file(keymap_file, keymap_content)
+
+
+def locate_keymap(keyboard, keymap, force_layout=None):
+    """Returns the path to a keymap for a specific keyboard.
+    """
+    if not qmk.path.is_keyboard(keyboard):
+        raise KeyError('Invalid keyboard: ' + repr(keyboard))
+
+    # Check the keyboard folder first, last match wins
+    keymap_path = ''
+
+    search_conf = {QMK_FIRMWARE: [keyboard_folder(keyboard)]}
+    if HAS_QMK_USERSPACE:
+        # When we've got userspace, check there _last_ as we want them to override anything in the main repo.
+        # We also want to search for any aliases as QMK's folder structure may have changed, with an alias, but the user
+        # hasn't updated their keymap location yet.
+        search_conf[QMK_USERSPACE] = list(set([keyboard_folder(keyboard), *keyboard_aliases(keyboard)]))
+
+    for search_dir, keyboard_dirs in search_conf.items():
+        for keyboard_dir in keyboard_dirs:
+            checked_dirs = ''
+            for folder_name in keyboard_dir.split('/'):
+                if checked_dirs:
+                    checked_dirs = '/'.join((checked_dirs, folder_name))
+                else:
+                    checked_dirs = folder_name
+
+                keymap_dir = Path(search_dir) / Path('keyboards') / checked_dirs / 'keymaps'
+
+                if (keymap_dir / keymap / 'keymap.c').exists():
+                    keymap_path = keymap_dir / keymap / 'keymap.c'
+                if (keymap_dir / keymap / 'keymap.json').exists():
+                    keymap_path = keymap_dir / keymap / 'keymap.json'
+
+        if keymap_path:
+            return keymap_path
+
+    # Check community layouts as a fallback
+    info = info_json(keyboard, force_layout=force_layout)
+
+    community_parents = list(Path('layouts').glob('*/'))
+    if HAS_QMK_USERSPACE and (Path(QMK_USERSPACE) / "layouts").exists():
+        community_parents.append(Path(QMK_USERSPACE) / "layouts")
+
+    for community_parent in community_parents:
+        for layout in info.get("community_layouts", []):
+            community_layout = community_parent / layout / keymap
+            if community_layout.exists():
+                if (community_layout / 'keymap.json').exists():
+                    return community_layout / 'keymap.json'
+                if (community_layout / 'keymap.c').exists():
+                    return community_layout / 'keymap.c'
+
+
+def is_keymap_target(keyboard, keymap):
+    if keymap == 'all':
+        return True
+
+    if locate_keymap(keyboard, keymap):
+        return True
+
+    return False
+
+
+def list_keymaps(keyboard, c=True, json=True, additional_files=None, fullpath=False, include_userspace=True):
+    """List the available keymaps for a keyboard.
+
+    Args:
+        keyboard
+            The keyboards full name with vendor and revision if necessary, example: clueboard/66/rev3
+
+        c
+            When true include `keymap.c` keymaps.
+
+        json
+            When true include `keymap.json` keymaps.
+
+        additional_files
+            A sequence of additional filenames to check against to determine if a directory is a keymap. All files must exist for a match to happen. For example, if you want to match a C keymap with both a `config.h` and `rules.mk` file: `is_keymap_dir(keymap_dir, json=False, additional_files=['config.h', 'rules.mk'])`
+
+        fullpath
+            When set to True the full path of the keymap relative to the `qmk_firmware` root will be provided.
+
+        include_userspace
+            When set to True, also search userspace for available keymaps
+
+    Returns:
+        a sorted list of valid keymap names.
+    """
+    names = set()
+
+    has_userspace = HAS_QMK_USERSPACE and include_userspace
+
+    # walk up the directory tree until keyboards_dir
+    # and collect all directories' name with keymap.c file in it
+    for search_dir in [QMK_FIRMWARE, QMK_USERSPACE] if has_userspace else [QMK_FIRMWARE]:
+        keyboards_dir = search_dir / Path('keyboards')
+        kb_path = keyboards_dir / keyboard
+
+        while kb_path != keyboards_dir:
+            keymaps_dir = kb_path / "keymaps"
+            if keymaps_dir.is_dir():
+                for keymap in keymaps_dir.iterdir():
+                    if is_keymap_dir(keymap, c, json, additional_files):
+                        keymap = keymap if fullpath else keymap.name
+                        names.add(keymap)
+
+            kb_path = kb_path.parent
+
+    # Check community layouts as a fallback
+    info = info_json(keyboard)
+
+    community_parents = list(Path('layouts').glob('*/'))
+    if has_userspace and (Path(QMK_USERSPACE) / "layouts").exists():
+        community_parents.append(Path(QMK_USERSPACE) / "layouts")
+
+    for community_parent in community_parents:
+        for layout in info.get("community_layouts", []):
+            cl_path = community_parent / layout
+            if cl_path.is_dir():
+                for keymap in cl_path.iterdir():
+                    if is_keymap_dir(keymap, c, json, additional_files):
+                        keymap = keymap if fullpath else keymap.name
+                        names.add(keymap)
+
+    return sorted(names)
+
+
+def _c_preprocess(path, stdin=DEVNULL):
+    """ Run a file through the C pre-processor
+
+    Args:
+        path: path of the keymap.c file (set None to use stdin)
+        stdin: stdin pipe (e.g. sys.stdin)
+
+    Returns:
+        the stdout of the pre-processor
+    """
+    cmd = ['cpp', str(path)] if path else ['cpp']
+    pre_processed_keymap = cli.run(cmd, stdin=stdin)
+    if 'fatal error' in pre_processed_keymap.stderr:
+        for line in pre_processed_keymap.stderr.split('\n'):
+            if 'fatal error' in line:
+                raise (CppError(line))
+    return pre_processed_keymap.stdout
+
+
+def _get_layers(keymap):  # noqa C901 : until someone has a good idea how to simplify/split up this code
+    """ Find the layers in a keymap.c file.
+
+    Args:
+        keymap: the content of the keymap.c file
+
+    Returns:
+        a dictionary containing the parsed keymap
+    """
+    layers = list()
+    opening_braces = '({['
+    closing_braces = ')}]'
+    keymap_certainty = brace_depth = 0
+    is_keymap = is_layer = is_adv_kc = False
+    layer = dict(name=False, layout=False, keycodes=list())
+    for line in lex(keymap, CLexer()):
+        if line[0] is Token.Name:
+            if is_keymap:
+                # If we are inside the keymap array
+                # we know the keymap's name and the layout macro will come,
+                # followed by the keycodes
+                if not layer['name']:
+                    if line[1].startswith('LAYOUT') or line[1].startswith('KEYMAP'):
+                        # This can happen if the keymap array only has one layer,
+                        # for macropads and such
+                        layer['name'] = '0'
+                        layer['layout'] = line[1]
+                    else:
+                        layer['name'] = line[1]
+                elif not layer['layout']:
+                    layer['layout'] = line[1]
+                elif is_layer:
+                    # If we are inside a layout macro,
+                    # collect all keycodes
+                    if line[1] == '_______':
+                        kc = 'KC_TRNS'
+                    elif line[1] == 'XXXXXXX':
+                        kc = 'KC_NO'
+                    else:
+                        kc = line[1]
+                    if is_adv_kc:
+                        # If we are inside an advanced keycode
+                        # collect everything and hope the user
+                        # knew what he/she was doing
+                        layer['keycodes'][-1] += kc
+                    else:
+                        layer['keycodes'].append(kc)
+
+        # The keymaps array's signature:
+        # const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS]
+        #
+        # Only if we've found all 6 keywords in this specific order
+        # can we know for sure that we are inside the keymaps array
+            elif line[1] == 'PROGMEM' and keymap_certainty == 2:
+                keymap_certainty = 3
+            elif line[1] == 'keymaps' and keymap_certainty == 3:
+                keymap_certainty = 4
+            elif line[1] == 'MATRIX_ROWS' and keymap_certainty == 4:
+                keymap_certainty = 5
+            elif line[1] == 'MATRIX_COLS' and keymap_certainty == 5:
+                keymap_certainty = 6
+        elif line[0] is Token.Keyword:
+            if line[1] == 'const' and keymap_certainty == 0:
+                keymap_certainty = 1
+        elif line[0] is Token.Keyword.Type:
+            if line[1] == 'uint16_t' and keymap_certainty == 1:
+                keymap_certainty = 2
+        elif line[0] is Token.Punctuation:
+            if line[1] in opening_braces:
+                brace_depth += 1
+                if is_keymap:
+                    if is_layer:
+                        # We found the beginning of a non-basic keycode
+                        is_adv_kc = True
+                        layer['keycodes'][-1] += line[1]
+                    elif line[1] == '(' and brace_depth == 2:
+                        # We found the beginning of a layer
+                        is_layer = True
+                elif line[1] == '{' and keymap_certainty == 6:
+                    # We found the beginning of the keymaps array
+                    is_keymap = True
+            elif line[1] in closing_braces:
+                brace_depth -= 1
+                if is_keymap:
+                    if is_adv_kc:
+                        layer['keycodes'][-1] += line[1]
+                        if brace_depth == 2:
+                            # We found the end of a non-basic keycode
+                            is_adv_kc = False
+                    elif line[1] == ')' and brace_depth == 1:
+                        # We found the end of a layer
+                        is_layer = False
+                        layers.append(layer)
+                        layer = dict(name=False, layout=False, keycodes=list())
+                    elif line[1] == '}' and brace_depth == 0:
+                        # We found the end of the keymaps array
+                        is_keymap = False
+                        keymap_certainty = 0
+            elif is_adv_kc:
+                # Advanced keycodes can contain other punctuation
+                # e.g.: MT(MOD_LCTL | MOD_LSFT, KC_ESC)
+                layer['keycodes'][-1] += line[1]
+
+        elif line[0] is Token.Literal.Number.Integer and is_keymap and not is_adv_kc:
+            # If the pre-processor finds the 'meaning' of the layer names,
+            # they will be numbers
+            if not layer['name']:
+                layer['name'] = line[1]
+
+        else:
+            # We only care about
+            # operators and such if we
+            # are inside an advanced keycode
+            # e.g.: MT(MOD_LCTL | MOD_LSFT, KC_ESC)
+            if is_adv_kc:
+                layer['keycodes'][-1] += line[1]
+
+    return layers
+
+
+def parse_keymap_c(keymap_file, use_cpp=True):
+    """ Parse a keymap.c file.
+
+    Currently only cares about the keymaps array.
+
+    Args:
+        keymap_file: path of the keymap.c file (or '-' to use stdin)
+
+        use_cpp: if True, pre-process the file with the C pre-processor
+
+    Returns:
+        a dictionary containing the parsed keymap
+    """
+    if not isinstance(keymap_file, (Path, str)) or keymap_file == '-':
+        if use_cpp:
+            keymap_file = _c_preprocess(None, sys.stdin)
+        else:
+            keymap_file = sys.stdin.read()
+    else:
+        if use_cpp:
+            keymap_file = _c_preprocess(keymap_file)
+        else:
+            keymap_file = keymap_file.read_text(encoding='utf-8')
+
+    keymap = dict()
+    keymap['layers'] = _get_layers(keymap_file)
+    return keymap
+
+
+def c2json(keyboard, keymap, keymap_file, use_cpp=True):
+    """ Convert keymap.c to keymap.json
+
+    Args:
+        keyboard: The name of the keyboard
+
+        keymap: The name of the keymap
+
+        layout: The LAYOUT macro this keymap uses.
+
+        keymap_file: path of the keymap.c file
+
+        use_cpp: if True, pre-process the file with the C pre-processor
+
+    Returns:
+        a dictionary in keymap.json format
+    """
+    keymap_json = parse_keymap_c(keymap_file, use_cpp)
+
+    dirty_layers = keymap_json.pop('layers', None)
+    keymap_json['layers'] = list()
+    for layer in dirty_layers:
+        layer.pop('name')
+        layout = layer.pop('layout')
+        if not keymap_json.get('layout', False):
+            keymap_json['layout'] = layout
+        keymap_json['layers'].append(layer.pop('keycodes'))
+
+    keymap_json['keyboard'] = keyboard
+    keymap_json['keymap'] = keymap
+    return keymap_json
diff --git a/lib/python/qmk/makefile.py b/lib/python/qmk/makefile.py
new file mode 100644
index 0000000000..ae95abbf23
--- /dev/null
+++ b/lib/python/qmk/makefile.py
@@ -0,0 +1,51 @@
+""" Functions for working with Makefiles
+"""
+from pathlib import Path
+
+
+def parse_rules_mk_file(file, rules_mk=None):
+    """Turn a rules.mk file into a dictionary.
+
+    Args:
+        file: path to the rules.mk file
+        rules_mk: already parsed rules.mk the new file should be merged with
+
+    Returns:
+        a dictionary with the file's content
+    """
+    if not rules_mk:
+        rules_mk = {}
+
+    file = Path(file)
+    if file.exists():
+        rules_mk_lines = file.read_text(encoding='utf-8').split("\n")
+
+        for line in rules_mk_lines:
+            # Filter out comments
+            if line.strip().startswith("#"):
+                continue
+
+            # Strip in-line comments
+            if '#' in line:
+                line = line[:line.index('#')].strip()
+
+            if '=' in line:
+                # Append
+                if '+=' in line:
+                    key, value = line.split('+=', 1)
+                    if key.strip() not in rules_mk:
+                        rules_mk[key.strip()] = value.strip()
+                    else:
+                        rules_mk[key.strip()] += ' ' + value.strip()
+                # Set if absent
+                elif "?=" in line:
+                    key, value = line.split('?=', 1)
+                    if key.strip() not in rules_mk:
+                        rules_mk[key.strip()] = value.strip()
+                else:
+                    if ":=" in line:
+                        line.replace(":", "")
+                    key, value = line.split('=', 1)
+                    rules_mk[key.strip()] = value.strip()
+
+    return rules_mk
diff --git a/lib/python/qmk/math_ops.py b/lib/python/qmk/math_ops.py
new file mode 100644
index 0000000000..1f14b18f4e
--- /dev/null
+++ b/lib/python/qmk/math_ops.py
@@ -0,0 +1,33 @@
+"""Parse arbitrary math equations in a safe way.
+
+Gratefully copied from https://stackoverflow.com/a/9558001
+"""
+import ast
+import operator as op
+
+# supported operators
+operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul, ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor, ast.USub: op.neg}
+
+
+def compute(expr):
+    """Parse a mathematical expression and return the answer.
+
+    >>> compute('2^6')
+    4
+    >>> compute('2**6')
+    64
+    >>> compute('1 + 2*3**(4^5) / (6 + -7)')
+    -5.0
+    """
+    return _eval(ast.parse(expr, mode='eval').body)
+
+
+def _eval(node):
+    if isinstance(node, ast.Constant):  # <number>
+        return node.value
+    elif isinstance(node, ast.BinOp):  # <left> <operator> <right>
+        return operators[type(node.op)](_eval(node.left), _eval(node.right))
+    elif isinstance(node, ast.UnaryOp):  # <operator> <operand> e.g., -1
+        return operators[type(node.op)](_eval(node.operand))
+    else:
+        raise TypeError(node)
diff --git a/lib/python/qmk/painter.py b/lib/python/qmk/painter.py
new file mode 100644
index 0000000000..1a07f7442c
--- /dev/null
+++ b/lib/python/qmk/painter.py
@@ -0,0 +1,456 @@
+"""Functions that help us work with Quantum Painter's file formats.
+"""
+import datetime
+import math
+import re
+from pathlib import Path
+from string import Template
+from PIL import Image, ImageOps
+
+# The list of valid formats Quantum Painter supports
+valid_formats = {
+    'rgb888': {
+        'image_format': 'IMAGE_FORMAT_RGB888',
+        'bpp': 24,
+        'has_palette': False,
+        'num_colors': 16777216,
+        'image_format_byte': 0x09,  # see qp_internal_formats.h
+    },
+    'rgb565': {
+        'image_format': 'IMAGE_FORMAT_RGB565',
+        'bpp': 16,
+        'has_palette': False,
+        'num_colors': 65536,
+        'image_format_byte': 0x08,  # see qp_internal_formats.h
+    },
+    'pal256': {
+        'image_format': 'IMAGE_FORMAT_PALETTE',
+        'bpp': 8,
+        'has_palette': True,
+        'num_colors': 256,
+        'image_format_byte': 0x07,  # see qp_internal_formats.h
+    },
+    'pal16': {
+        'image_format': 'IMAGE_FORMAT_PALETTE',
+        'bpp': 4,
+        'has_palette': True,
+        'num_colors': 16,
+        'image_format_byte': 0x06,  # see qp_internal_formats.h
+    },
+    'pal4': {
+        'image_format': 'IMAGE_FORMAT_PALETTE',
+        'bpp': 2,
+        'has_palette': True,
+        'num_colors': 4,
+        'image_format_byte': 0x05,  # see qp_internal_formats.h
+    },
+    'pal2': {
+        'image_format': 'IMAGE_FORMAT_PALETTE',
+        'bpp': 1,
+        'has_palette': True,
+        'num_colors': 2,
+        'image_format_byte': 0x04,  # see qp_internal_formats.h
+    },
+    'mono256': {
+        'image_format': 'IMAGE_FORMAT_GRAYSCALE',
+        'bpp': 8,
+        'has_palette': False,
+        'num_colors': 256,
+        'image_format_byte': 0x03,  # see qp_internal_formats.h
+    },
+    'mono16': {
+        'image_format': 'IMAGE_FORMAT_GRAYSCALE',
+        'bpp': 4,
+        'has_palette': False,
+        'num_colors': 16,
+        'image_format_byte': 0x02,  # see qp_internal_formats.h
+    },
+    'mono4': {
+        'image_format': 'IMAGE_FORMAT_GRAYSCALE',
+        'bpp': 2,
+        'has_palette': False,
+        'num_colors': 4,
+        'image_format_byte': 0x01,  # see qp_internal_formats.h
+    },
+    'mono2': {
+        'image_format': 'IMAGE_FORMAT_GRAYSCALE',
+        'bpp': 1,
+        'has_palette': False,
+        'num_colors': 2,
+        'image_format_byte': 0x00,  # see qp_internal_formats.h
+    }
+}
+
+
+def _render_text(values):
+    # FIXME: May need more chars with GIFs containing lots of frames (or longer durations)
+    return "|".join([f"{i:4d}" for i in values])
+
+
+def _render_numeration(metadata):
+    return _render_text(range(len(metadata)))
+
+
+def _render_values(metadata, key):
+    return _render_text([i[key] for i in metadata])
+
+
+def _render_image_metadata(metadata):
+    size = metadata.pop(0)
+
+    lines = [
+        "// Image's metadata",
+        "// ----------------",
+        f"// Width: {size['width']}",
+        f"// Height: {size['height']}",
+    ]
+
+    if len(metadata) == 1:
+        lines.append("// Single frame")
+
+    else:
+        lines.extend([
+            f"//        Frame: {_render_numeration(metadata)}",
+            f"// Duration(ms): {_render_values(metadata, 'delay')}",
+            f"//  Compression: {_render_values(metadata, 'compression')} >> See qp.h, painter_compression_t",
+            f"//        Delta: {_render_values(metadata, 'delta')}",
+        ])
+
+        deltas = []
+        for i, v in enumerate(metadata):
+            # Not a delta frame, go to next one
+            if not v["delta"]:
+                continue
+
+            # Unpack rect's coords
+            l, t, r, b = v["delta_rect"]
+
+            delta_px = (r - l) * (b - t)
+            px = size["width"] * size["height"]
+
+            # FIXME: May need need more chars here too
+            deltas.append(f"// Frame {i:3d}: ({l:3d}, {t:3d}) - ({r:3d}, {b:3d}) >> {delta_px:4d}/{px:4d} pixels ({100 * delta_px / px:.2f}%)")
+
+        if deltas:
+            lines.append("// Areas on delta frames")
+            lines.extend(deltas)
+
+    return "\n".join(lines)
+
+
+def command_args_str(cli, command_name):
+    """Given a command name, introspect milc to get the arguments passed in."""
+
+    args = {}
+    max_length = 0
+    for arg_name, was_passed in cli.args_passed[command_name].items():
+        max_length = max(max_length, len(arg_name))
+
+        val = getattr(cli.args, arg_name.replace("-", "_"))
+
+        # do not leak full paths, keep just file name
+        if isinstance(val, Path):
+            val = val.name
+
+        args[arg_name] = val
+
+    return "\n".join(f"//    {arg_name.ljust(max_length)} | {val}" for arg_name, val in args.items())
+
+
+def generate_subs(cli, out_bytes, *, font_metadata=None, image_metadata=None, command_name):
+    if font_metadata is not None and image_metadata is not None:
+        raise ValueError("Cant generate subs for font and image at the same time")
+
+    args = command_args_str(cli, command_name)
+
+    subs = {
+        "year": datetime.date.today().strftime("%Y"),
+        "input_file": cli.args.input.name,
+        "sane_name": re.sub(r"[^a-zA-Z0-9]", "_", cli.args.input.stem),
+        "byte_count": len(out_bytes),
+        "bytes_lines": render_bytes(out_bytes),
+        "format": cli.args.format,
+        "generator_command": command_name.replace("_", "-"),
+        "command_args": args,
+    }
+
+    if font_metadata is not None:
+        subs.update({
+            "generated_type": "font",
+            "var_prefix": "font",
+            # not using triple quotes to avoid extra indentation/weird formatted code
+            "metadata": "\n".join([
+                "// Font's metadata",
+                "// ---------------",
+                f"// Glyphs: {', '.join([i for i in font_metadata['glyphs']])}",
+            ]),
+        })
+
+    elif image_metadata is not None:
+        subs.update({
+            "generated_type": "image",
+            "var_prefix": "gfx",
+            "generator_command": command_name,
+            "metadata": _render_image_metadata(image_metadata),
+        })
+
+    else:
+        raise ValueError("Pass metadata for either an image or a font")
+
+    subs.update({"license": render_license(subs)})
+
+    return subs
+
+
+license_template = """\
+// Copyright ${year} QMK -- generated source code only, ${generated_type} retains original copyright
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+// This file was auto-generated by `${generator_command}` with arguments:
+${command_args}
+"""
+
+
+def render_license(subs):
+    license_txt = Template(license_template)
+    return license_txt.substitute(subs)
+
+
+header_file_template = """\
+${license}
+#pragma once
+
+#include <qp.h>
+
+extern const uint32_t ${var_prefix}_${sane_name}_length;
+extern const uint8_t  ${var_prefix}_${sane_name}[${byte_count}];
+"""
+
+
+def render_header(subs):
+    header_txt = Template(header_file_template)
+    return header_txt.substitute(subs)
+
+
+source_file_template = """\
+${license}
+${metadata}
+
+#include <qp.h>
+
+const uint32_t ${var_prefix}_${sane_name}_length = ${byte_count};
+
+// clang-format off
+const uint8_t ${var_prefix}_${sane_name}[${byte_count}] = {
+${bytes_lines}
+};
+// clang-format on
+"""
+
+
+def render_source(subs):
+    source_txt = Template(source_file_template)
+    return source_txt.substitute(subs)
+
+
+def render_bytes(bytes, newline_after=16):
+    lines = ''
+    for n in range(len(bytes)):
+        if n % newline_after == 0 and n > 0 and n != len(bytes):
+            lines = lines + "\n   "
+        elif n == 0:
+            lines = lines + "   "
+        lines = lines + " 0x{0:02X},".format(bytes[n])
+    return lines.rstrip()
+
+
+def clean_output(str):
+    str = re.sub(r'\r', '', str)
+    str = re.sub(r'[\n]{3,}', r'\n\n', str)
+    return str
+
+
+def rescale_byte(val, maxval):
+    """Rescales a byte value to the supplied range, i.e. [0,255] -> [0,maxval].
+    """
+    return int(round(val * maxval / 255.0))
+
+
+def convert_requested_format(im, format):
+    """Convert an image to the requested format.
+    """
+
+    # Work out the requested format
+    ncolors = format["num_colors"]
+    image_format = format["image_format"]
+
+    # -- Check if ncolors is valid
+    # Formats accepting several options
+    if image_format in ['IMAGE_FORMAT_GRAYSCALE', 'IMAGE_FORMAT_PALETTE']:
+        valid = [2, 4, 8, 16, 256]
+
+    # Formats expecting a particular number
+    else:
+        # Read number from specs dict, instead of hardcoding
+        for _, fmt in valid_formats.items():
+            if fmt["image_format"] == image_format:
+                # has to be an iterable, to use `in`
+                valid = [fmt["num_colors"]]
+                break
+
+    if ncolors not in valid:
+        raise ValueError(f"Number of colors must be: {', '.join(valid)}.")
+
+    # Work out where we're getting the bytes from
+    if image_format == 'IMAGE_FORMAT_GRAYSCALE':
+        # If mono, convert input to grayscale, then to RGB, then grab the raw bytes corresponding to the intensity of the red channel
+        im = ImageOps.grayscale(im)
+        im = im.convert("RGB")
+    elif image_format == 'IMAGE_FORMAT_PALETTE':
+        # If color, convert input to RGB, palettize based on the supplied number of colors, then get the raw palette bytes
+        im = im.convert("RGB")
+        im = im.convert("P", palette=Image.ADAPTIVE, colors=ncolors)
+    elif image_format in ['IMAGE_FORMAT_RGB565', 'IMAGE_FORMAT_RGB888']:
+        # Convert input to RGB
+        im = im.convert("RGB")
+
+    return im
+
+
+def rgb_to565(r, g, b):
+    msb = ((r >> 3 & 0x1F) << 3) + (g >> 5 & 0x07)
+    lsb = ((g >> 2 & 0x07) << 5) + (b >> 3 & 0x1F)
+    return [msb, lsb]
+
+
+def convert_image_bytes(im, format):
+    """Convert the supplied image to the equivalent bytes required by the QMK firmware.
+    """
+
+    # Work out the requested format
+    ncolors = format["num_colors"]
+    image_format = format["image_format"]
+    shifter = int(math.log2(ncolors))
+    pixels_per_byte = int(8 / math.log2(ncolors))
+    bytes_per_pixel = math.ceil(math.log2(ncolors) / 8)
+    (width, height) = im.size
+    if (pixels_per_byte != 0):
+        expected_byte_count = ((width * height) + (pixels_per_byte - 1)) // pixels_per_byte
+    else:
+        expected_byte_count = width * height * bytes_per_pixel
+
+    if image_format == 'IMAGE_FORMAT_GRAYSCALE':
+        # Take the red channel
+        image_bytes = im.tobytes("raw", "R")
+        image_bytes_len = len(image_bytes)
+
+        # No palette
+        palette = None
+
+        bytearray = []
+        for x in range(expected_byte_count):
+            byte = 0
+            for n in range(pixels_per_byte):
+                byte_offset = x * pixels_per_byte + n
+                if byte_offset < image_bytes_len:
+                    # If mono, each input byte is a grayscale [0,255] pixel -- rescale to the range we want then pack together
+                    byte = byte | (rescale_byte(image_bytes[byte_offset], ncolors - 1) << int(n * shifter))
+            bytearray.append(byte)
+
+    elif image_format == 'IMAGE_FORMAT_PALETTE':
+        # Convert each pixel to the palette bytes
+        image_bytes = im.tobytes("raw", "P")
+        image_bytes_len = len(image_bytes)
+
+        # Export the palette
+        palette = []
+        pal = im.getpalette()
+        for n in range(0, ncolors * 3, 3):
+            palette.append((pal[n + 0], pal[n + 1], pal[n + 2]))
+
+        bytearray = []
+        for x in range(expected_byte_count):
+            byte = 0
+            for n in range(pixels_per_byte):
+                byte_offset = x * pixels_per_byte + n
+                if byte_offset < image_bytes_len:
+                    # If color, each input byte is the index into the color palette -- pack them together
+                    byte = byte | ((image_bytes[byte_offset] & (ncolors - 1)) << int(n * shifter))
+            bytearray.append(byte)
+
+    if image_format == 'IMAGE_FORMAT_RGB565':
+        # Take the red, green, and blue channels
+        red = im.tobytes("raw", "R")
+        green = im.tobytes("raw", "G")
+        blue = im.tobytes("raw", "B")
+
+        # No palette
+        palette = None
+
+        bytearray = [byte for r, g, b in zip(red, green, blue) for byte in rgb_to565(r, g, b)]
+
+    if image_format == 'IMAGE_FORMAT_RGB888':
+        # Take the red, green, and blue channels
+        red = im.tobytes("raw", "R")
+        green = im.tobytes("raw", "G")
+        blue = im.tobytes("raw", "B")
+
+        # No palette
+        palette = None
+
+        bytearray = [byte for r, g, b in zip(red, green, blue) for byte in (r, g, b)]
+
+    if len(bytearray) != expected_byte_count:
+        raise Exception(f"Wrong byte count, was {len(bytearray)}, expected {expected_byte_count}")
+
+    return (palette, bytearray)
+
+
+def compress_bytes_qmk_rle(bytearray):
+    debug_dump = False
+    output = []
+    temp = []
+    repeat = False
+
+    def append_byte(c):
+        if debug_dump:
+            print('Appending byte:', '0x{0:02X}'.format(int(c)), '=', c)
+        output.append(c)
+
+    def append_range(r):
+        append_byte(127 + len(r))
+        if debug_dump:
+            print('Appending {0} byte(s):'.format(len(r)), '[', ', '.join(['{0:02X}'.format(e) for e in r]), ']')
+        output.extend(r)
+
+    for n in range(0, len(bytearray) + 1):
+        end = True if n == len(bytearray) else False
+        if not end:
+            c = bytearray[n]
+            temp.append(c)
+            if len(temp) <= 1:
+                continue
+
+        if debug_dump:
+            print('Temp buffer state {0:3d} bytes:'.format(len(temp)), '[', ', '.join(['{0:02X}'.format(e) for e in temp]), ']')
+
+        if repeat:
+            if temp[-1] != temp[-2]:
+                repeat = False
+            if not repeat or len(temp) == 128 or end:
+                append_byte(len(temp) if end else len(temp) - 1)
+                append_byte(temp[0])
+                temp = [temp[-1]]
+                repeat = False
+        else:
+            if len(temp) >= 2 and temp[-1] == temp[-2]:
+                repeat = True
+                if len(temp) > 2:
+                    append_range(temp[0:(len(temp) - 2)])
+                    temp = [temp[-1], temp[-1]]
+                continue
+            if len(temp) == 128 or end:
+                append_range(temp)
+                temp = []
+                repeat = False
+    return output
diff --git a/lib/python/qmk/painter_qff.py b/lib/python/qmk/painter_qff.py
new file mode 100644
index 0000000000..746bb166e5
--- /dev/null
+++ b/lib/python/qmk/painter_qff.py
@@ -0,0 +1,401 @@
+# Copyright 2021 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Quantum Font File "QFF" Font File Format.
+# See https://docs.qmk.fm/#/quantum_painter_qff for more information.
+
+from pathlib import Path
+from typing import Dict, Any
+from colorsys import rgb_to_hsv
+from PIL import Image, ImageDraw, ImageFont, ImageChops
+from PIL._binary import o8, o16le as o16, o32le as o32
+from qmk.painter_qgf import QGFBlockHeader, QGFFramePaletteDescriptorV1
+from milc.attrdict import AttrDict
+import qmk.painter
+
+
+def o24(i):
+    return o16(i & 0xFFFF) + o8((i & 0xFF0000) >> 16)
+
+
+########################################################################################################################
+
+
+class QFFGlyphInfo(AttrDict):
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+
+        for n, value in enumerate(args):
+            self[f'arg:{n}'] = value
+
+        for key, value in kwargs.items():
+            self[key] = value
+
+    def write(self, fp, include_code_point):
+        if include_code_point is True:
+            fp.write(o24(ord(self.code_point)))
+
+        value = ((self.data_offset << 6) & 0xFFFFC0) | (self.w & 0x3F)
+        fp.write(o24(value))
+
+
+########################################################################################################################
+
+
+class QFFFontDescriptor:
+    type_id = 0x00
+    length = 20
+    magic = 0x464651
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QFFFontDescriptor.type_id
+        self.header.length = QFFFontDescriptor.length
+        self.version = 1
+        self.total_file_size = 0
+        self.line_height = 0
+        self.has_ascii_table = False
+        self.unicode_glyph_count = 0
+        self.format = 0xFF
+        self.flags = 0
+        self.compression = 0xFF
+        self.transparency_index = 0xFF  # TODO: Work out how to retrieve the transparent palette entry from the PIL gif loader
+
+    def write(self, fp):
+        self.header.write(fp)
+        fp.write(
+            b''  # start off with empty bytes...
+            + o24(QFFFontDescriptor.magic)  # magic
+            + o8(self.version)  # version
+            + o32(self.total_file_size)  # file size
+            + o32((~self.total_file_size) & 0xFFFFFFFF)  # negated file size
+            + o8(self.line_height)  # line height
+            + o8(1 if self.has_ascii_table is True else 0)  # whether or not we have an ascii table present
+            + o16(self.unicode_glyph_count & 0xFFFF)  # number of unicode glyphs present
+            + o8(self.format)  # format
+            + o8(self.flags)  # flags
+            + o8(self.compression)  # compression
+            + o8(self.transparency_index)  # transparency index
+        )
+
+    @property
+    def is_transparent(self):
+        return (self.flags & 0x01) == 0x01
+
+    @is_transparent.setter
+    def is_transparent(self, val):
+        if val:
+            self.flags |= 0x01
+        else:
+            self.flags &= ~0x01
+
+
+########################################################################################################################
+
+
+class QFFAsciiGlyphTableV1:
+    type_id = 0x01
+    length = 95 * 3  # We have 95 glyphs: [0x20...0x7E]
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QFFAsciiGlyphTableV1.type_id
+        self.header.length = QFFAsciiGlyphTableV1.length
+
+        # Each glyph is key=code_point, value=QFFGlyphInfo
+        self.glyphs = {}
+
+    def add_glyph(self, glyph: QFFGlyphInfo):
+        self.glyphs[ord(glyph.code_point)] = glyph
+
+    def write(self, fp):
+        self.header.write(fp)
+
+        for n in range(0x20, 0x7F):
+            self.glyphs[n].write(fp, False)
+
+
+########################################################################################################################
+
+
+class QFFUnicodeGlyphTableV1:
+    type_id = 0x02
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QFFUnicodeGlyphTableV1.type_id
+        self.header.length = 0
+
+        # Each glyph is key=code_point, value=QFFGlyphInfo
+        self.glyphs = {}
+
+    def add_glyph(self, glyph: QFFGlyphInfo):
+        self.glyphs[ord(glyph.code_point)] = glyph
+
+    def write(self, fp):
+        self.header.length = len(self.glyphs.keys()) * 6
+        self.header.write(fp)
+
+        for n in sorted(self.glyphs.keys()):
+            self.glyphs[n].write(fp, True)
+
+
+########################################################################################################################
+
+
+class QFFFontDataDescriptorV1:
+    type_id = 0x04
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QFFFontDataDescriptorV1.type_id
+        self.data = []
+
+    def write(self, fp):
+        self.header.length = len(self.data)
+        self.header.write(fp)
+        fp.write(bytes(self.data))
+
+
+########################################################################################################################
+
+
+def _generate_font_glyphs_list(use_ascii, unicode_glyphs):
+    # The set of glyphs that we want to generate images for
+    glyphs = {}
+
+    # Add ascii charset if requested
+    if use_ascii is True:
+        for c in range(0x20, 0x7F):  # does not include 0x7F!
+            glyphs[chr(c)] = True
+
+    # Append any extra unicode glyphs
+    unicode_glyphs = list(unicode_glyphs)
+    for c in unicode_glyphs:
+        glyphs[c] = True
+
+    return sorted(glyphs.keys())
+
+
+class QFFFont:
+    def __init__(self, logger):
+        self.logger = logger
+        self.image = None
+        self.glyph_data = {}
+        self.glyph_height = 0
+        return
+
+    def _extract_glyphs(self, format):
+        total_data_size = 0
+        total_rle_data_size = 0
+
+        converted_img = qmk.painter.convert_requested_format(self.image, format)
+        (self.palette, _) = qmk.painter.convert_image_bytes(converted_img, format)
+
+        # Work out how many bytes used for RLE vs. non-RLE
+        for _, glyph_entry in self.glyph_data.items():
+            glyph_img = converted_img.crop((glyph_entry.x, 1, glyph_entry.x + glyph_entry.w, 1 + self.glyph_height))
+            (_, this_glyph_image_bytes) = qmk.painter.convert_image_bytes(glyph_img, format)
+            this_glyph_rle_bytes = qmk.painter.compress_bytes_qmk_rle(this_glyph_image_bytes)
+            total_data_size += len(this_glyph_image_bytes)
+            total_rle_data_size += len(this_glyph_rle_bytes)
+            glyph_entry['image_uncompressed_bytes'] = this_glyph_image_bytes
+            glyph_entry['image_compressed_bytes'] = this_glyph_rle_bytes
+
+        return (total_data_size, total_rle_data_size)
+
+    def _parse_image(self, img, include_ascii_glyphs: bool = True, unicode_glyphs: str = ''):
+        # Clear out any existing font metadata
+        self.image = None
+        # Each glyph is key=code_point, value={ x: ?, w: ? }
+        self.glyph_data = {}
+        self.glyph_height = 0
+
+        # Work out the list of glyphs required
+        glyphs = _generate_font_glyphs_list(include_ascii_glyphs, unicode_glyphs)
+
+        # Work out the geometry
+        (width, height) = img.size
+
+        # Work out the glyph offsets/widths
+        glyph_pixel_offsets = []
+        glyph_pixel_widths = []
+        pixels = img.load()
+
+        # Run through the markers and work out where each glyph starts/stops
+        glyph_split_color = pixels[0, 0]  # top left pixel is the marker color we're going to use to split each glyph
+        glyph_pixel_offsets.append(0)
+        last_offset = 0
+        for x in range(1, width):
+            if pixels[x, 0] == glyph_split_color:
+                glyph_pixel_offsets.append(x)
+                glyph_pixel_widths.append(x - last_offset)
+                last_offset = x
+        glyph_pixel_widths.append(width - last_offset)
+
+        # Make sure the number of glyphs we're attempting to generate matches the input image
+        if len(glyph_pixel_offsets) != len(glyphs):
+            self.logger.error('The number of glyphs to generate doesn\'t match the number of detected glyphs in the input image.')
+            return
+
+        # Set up the required metadata for each glyph
+        for n in range(0, len(glyph_pixel_offsets)):
+            self.glyph_data[glyphs[n]] = QFFGlyphInfo(code_point=glyphs[n], x=glyph_pixel_offsets[n], w=glyph_pixel_widths[n])
+
+        # Parsing was successful, keep the image in this instance
+        self.image = img
+        self.glyph_height = height - 1  # subtract the line with the markers
+
+    def generate_image(self, ttf_file: Path, font_size: int, include_ascii_glyphs: bool = True, unicode_glyphs: str = '', include_before_left: bool = False, use_aa: bool = True):
+        # Load the font
+        font = ImageFont.truetype(str(ttf_file), int(font_size))
+        # Work out the max font size
+        max_font_size = font.font.ascent + abs(font.font.descent)
+        # Work out the list of glyphs required
+        glyphs = _generate_font_glyphs_list(include_ascii_glyphs, unicode_glyphs)
+
+        baseline_offset = 9999999
+        total_glyph_width = 0
+        max_glyph_height = -1
+
+        # Measure each glyph to determine the overall baseline offset required
+        for glyph in glyphs:
+            (ls_l, ls_t, ls_r, ls_b) = font.getbbox(glyph, anchor='ls')
+            glyph_width = (ls_r - ls_l) if include_before_left else (ls_r)
+            glyph_height = font.getbbox(glyph, anchor='la')[3]
+            if max_glyph_height < glyph_height:
+                max_glyph_height = glyph_height
+            total_glyph_width += glyph_width
+            if baseline_offset > ls_t:
+                baseline_offset = ls_t
+
+        # Create the output image
+        img = Image.new("RGB", (total_glyph_width + 1, max_font_size * 2 + 1), (0, 0, 0, 255))
+        cur_x_pos = 0
+
+        # Loop through each glyph...
+        for glyph in glyphs:
+            # Work out this glyph's bounding box
+            (ls_l, ls_t, ls_r, ls_b) = font.getbbox(glyph, anchor='ls')
+            glyph_width = (ls_r - ls_l) if include_before_left else (ls_r)
+            glyph_height = ls_b - ls_t
+            x_offset = -ls_l
+            y_offset = ls_t - baseline_offset
+
+            # Draw each glyph to its own image so we don't get anti-aliasing applied to the final image when straddling edges
+            glyph_img = Image.new("RGB", (glyph_width, max_font_size), (0, 0, 0, 255))
+            glyph_draw = ImageDraw.Draw(glyph_img)
+            if not use_aa:
+                glyph_draw.fontmode = "1"
+            glyph_draw.text((x_offset, y_offset), glyph, font=font, anchor='lt')
+
+            # Place the glyph-specific image in the correct location overall
+            img.paste(glyph_img, (cur_x_pos, 1))
+
+            # Set up the marker for start of each glyph
+            pixels = img.load()
+            pixels[cur_x_pos, 0] = (255, 0, 255)
+
+            # Increment for the next glyph's position
+            cur_x_pos += glyph_width
+
+        # Add the ending marker so that the difference/crop works
+        pixels = img.load()
+        pixels[cur_x_pos, 0] = (255, 0, 255)
+
+        # Determine the usable font area
+        dummy_img = Image.new("RGB", (total_glyph_width + 1, max_font_size + 1), (0, 0, 0, 255))
+        bbox = ImageChops.difference(img, dummy_img).getbbox()
+        bbox = (bbox[0], bbox[1], bbox[2] - 1, bbox[3])  # remove the unused end-marker
+
+        # Crop and re-parse the resulting image to ensure we're generating the correct format
+        self._parse_image(img.crop(bbox), include_ascii_glyphs, unicode_glyphs)
+
+    def save_to_image(self, img_file: Path):
+        # Drop out if there's no image loaded
+        if self.image is None:
+            self.logger.error('No image is loaded.')
+            return
+
+        # Save the image to the supplied file
+        self.image.save(str(img_file))
+
+    def read_from_image(self, img_file: Path, include_ascii_glyphs: bool = True, unicode_glyphs: str = ''):
+        # Load and parse the supplied image file
+        self._parse_image(Image.open(str(img_file)), include_ascii_glyphs, unicode_glyphs)
+        return
+
+    def save_to_qff(self, format: Dict[str, Any], use_rle: bool, fp):
+        # Drop out if there's no image loaded
+        if self.image is None:
+            self.logger.error('No image is loaded.')
+            return
+
+        # Work out if we want to use RLE at all, skipping it if it's not any smaller (it's applied per-glyph)
+        (total_data_size, total_rle_data_size) = self._extract_glyphs(format)
+        if use_rle:
+            use_rle = (total_rle_data_size < total_data_size)
+
+        # For each glyph, work out which image data we want to use and append it to the image buffer, recording the byte-wise offset
+        img_buffer = bytes()
+        for _, glyph_entry in self.glyph_data.items():
+            glyph_entry['data_offset'] = len(img_buffer)
+            glyph_img_bytes = glyph_entry.image_compressed_bytes if use_rle else glyph_entry.image_uncompressed_bytes
+            img_buffer += bytes(glyph_img_bytes)
+
+        font_descriptor = QFFFontDescriptor()
+        ascii_table = QFFAsciiGlyphTableV1()
+        unicode_table = QFFUnicodeGlyphTableV1()
+        data_descriptor = QFFFontDataDescriptorV1()
+        data_descriptor.data = img_buffer
+
+        # Check if we have all the ASCII glyphs present
+        include_ascii_glyphs = all([chr(n) in self.glyph_data for n in range(0x20, 0x7F)])
+
+        # Helper for populating the blocks
+        for code_point, glyph_entry in self.glyph_data.items():
+            if ord(code_point) >= 0x20 and ord(code_point) <= 0x7E and include_ascii_glyphs:
+                ascii_table.add_glyph(glyph_entry)
+            else:
+                unicode_table.add_glyph(glyph_entry)
+
+        # Configure the font descriptor
+        font_descriptor.line_height = self.glyph_height
+        font_descriptor.has_ascii_table = include_ascii_glyphs
+        font_descriptor.unicode_glyph_count = len(unicode_table.glyphs.keys())
+        font_descriptor.is_transparent = False
+        font_descriptor.format = format['image_format_byte']
+        font_descriptor.compression = 0x01 if use_rle else 0x00
+
+        # Write a dummy font descriptor -- we'll have to come back and write it properly once we've rendered out everything else
+        font_descriptor_location = fp.tell()
+        font_descriptor.write(fp)
+
+        # Write out the ASCII table if required
+        if font_descriptor.has_ascii_table:
+            ascii_table.write(fp)
+
+        # Write out the unicode table if required
+        if font_descriptor.unicode_glyph_count > 0:
+            unicode_table.write(fp)
+
+        # Write out the palette if required
+        if format['has_palette']:
+            palette_descriptor = QGFFramePaletteDescriptorV1()
+
+            # Helper to convert from RGB888 to the QMK "dialect" of HSV888
+            def rgb888_to_qmk_hsv888(e):
+                hsv = rgb_to_hsv(e[0] / 255.0, e[1] / 255.0, e[2] / 255.0)
+                return (int(hsv[0] * 255.0), int(hsv[1] * 255.0), int(hsv[2] * 255.0))
+
+            # Convert all palette entries to HSV888 and write to the output
+            palette_descriptor.palette_entries = list(map(rgb888_to_qmk_hsv888, self.palette))
+            palette_descriptor.write(fp)
+
+        # Write out the image data
+        data_descriptor.write(fp)
+
+        # Now fix up the overall font descriptor, then write it in the correct location
+        font_descriptor.total_file_size = fp.tell()
+        fp.seek(font_descriptor_location, 0)
+        font_descriptor.write(fp)
diff --git a/lib/python/qmk/painter_qgf.py b/lib/python/qmk/painter_qgf.py
new file mode 100644
index 0000000000..67ef0dd233
--- /dev/null
+++ b/lib/python/qmk/painter_qgf.py
@@ -0,0 +1,460 @@
+# Copyright 2021 Nick Brassel (@tzarc)
+# Copyright 2023 Pablo Martinez (@elpekenin) <elpekenin@elpekenin.dev>
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# Quantum Graphics File "QGF" Image File Format.
+# See https://docs.qmk.fm/#/quantum_painter_qgf for more information.
+
+import functools
+from colorsys import rgb_to_hsv
+from types import FunctionType
+from PIL import Image, ImageFile, ImageChops
+from PIL._binary import o8, o16le as o16, o32le as o32
+import qmk.painter
+
+
+def o24(i):
+    return o16(i & 0xFFFF) + o8((i & 0xFF0000) >> 16)
+
+
+# Helper to convert from RGB888 to the QMK "dialect" of HSV888
+def rgb888_to_qmk_hsv888(e):
+    hsv = rgb_to_hsv(e[0] / 255.0, e[1] / 255.0, e[2] / 255.0)
+    return (int(hsv[0] * 255.0), int(hsv[1] * 255.0), int(hsv[2] * 255.0))
+
+
+########################################################################################################################
+
+
+class QGFBlockHeader:
+    block_size = 5
+
+    def write(self, fp):
+        fp.write(b''  # start off with empty bytes...
+                 + o8(self.type_id)  # block type id
+                 + o8((~self.type_id) & 0xFF)  # negated block type id
+                 + o24(self.length)  # blob length
+                 )
+
+
+########################################################################################################################
+
+
+class QGFGraphicsDescriptor:
+    type_id = 0x00
+    length = 18
+    magic = 0x464751
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFGraphicsDescriptor.type_id
+        self.header.length = QGFGraphicsDescriptor.length
+        self.version = 1
+        self.total_file_size = 0
+        self.image_width = 0
+        self.image_height = 0
+        self.frame_count = 0
+
+    def write(self, fp):
+        self.header.write(fp)
+        fp.write(
+            b''  # start off with empty bytes...
+            + o24(QGFGraphicsDescriptor.magic)  # magic
+            + o8(self.version)  # version
+            + o32(self.total_file_size)  # file size
+            + o32((~self.total_file_size) & 0xFFFFFFFF)  # negated file size
+            + o16(self.image_width)  # width
+            + o16(self.image_height)  # height
+            + o16(self.frame_count)  # frame count
+        )
+
+    @property
+    def image_size(self):
+        return self.image_width, self.image_height
+
+    @image_size.setter
+    def image_size(self, size):
+        self.image_width, self.image_height = size
+
+
+########################################################################################################################
+
+
+class QGFFrameOffsetDescriptorV1:
+    type_id = 0x01
+
+    def __init__(self, frame_count):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFFrameOffsetDescriptorV1.type_id
+        self.frame_offsets = [0xFFFFFFFF] * frame_count
+        self.frame_count = frame_count
+
+    def write(self, fp):
+        self.header.length = len(self.frame_offsets) * 4
+        self.header.write(fp)
+        for offset in self.frame_offsets:
+            fp.write(b''  # start off with empty bytes...
+                     + o32(offset)  # offset
+                     )
+
+
+########################################################################################################################
+
+
+class QGFFrameDescriptorV1:
+    type_id = 0x02
+    length = 6
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFFrameDescriptorV1.type_id
+        self.header.length = QGFFrameDescriptorV1.length
+        self.format = 0xFF
+        self.flags = 0
+        self.compression = 0xFF
+        self.transparency_index = 0xFF  # TODO: Work out how to retrieve the transparent palette entry from the PIL gif loader
+        self.delay = 1000  # Placeholder until it gets read from the animation
+
+    def write(self, fp):
+        self.header.write(fp)
+        fp.write(b''  # start off with empty bytes...
+                 + o8(self.format)  # format
+                 + o8(self.flags)  # flags
+                 + o8(self.compression)  # compression
+                 + o8(self.transparency_index)  # transparency index
+                 + o16(self.delay)  # delay
+                 )
+
+    @property
+    def is_transparent(self):
+        return (self.flags & 0x01) == 0x01
+
+    @is_transparent.setter
+    def is_transparent(self, val):
+        if val:
+            self.flags |= 0x01
+        else:
+            self.flags &= ~0x01
+
+    @property
+    def is_delta(self):
+        return (self.flags & 0x02) == 0x02
+
+    @is_delta.setter
+    def is_delta(self, val):
+        if val:
+            self.flags |= 0x02
+        else:
+            self.flags &= ~0x02
+
+
+########################################################################################################################
+
+
+class QGFFramePaletteDescriptorV1:
+    type_id = 0x03
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFFramePaletteDescriptorV1.type_id
+        self.header.length = 0
+        self.palette_entries = [(0xFF, 0xFF, 0xFF)] * 4
+
+    def write(self, fp):
+        self.header.length = len(self.palette_entries) * 3
+        self.header.write(fp)
+        for entry in self.palette_entries:
+            fp.write(b''  # start off with empty bytes...
+                     + o8(entry[0])  # h
+                     + o8(entry[1])  # s
+                     + o8(entry[2])  # v
+                     )
+
+
+########################################################################################################################
+
+
+class QGFFrameDeltaDescriptorV1:
+    type_id = 0x04
+    length = 8
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFFrameDeltaDescriptorV1.type_id
+        self.header.length = QGFFrameDeltaDescriptorV1.length
+        self.left = 0
+        self.top = 0
+        self.right = 0
+        self.bottom = 0
+
+    def write(self, fp):
+        self.header.write(fp)
+        fp.write(b''  # start off with empty bytes...
+                 + o16(self.left)  # left
+                 + o16(self.top)  # top
+                 + o16(self.right)  # right
+                 + o16(self.bottom)  # bottom
+                 )
+
+    @property
+    def bbox(self):
+        return self.left, self.top, self.right, self.bottom
+
+    @bbox.setter
+    def bbox(self, bbox):
+        self.left, self.top, self.right, self.bottom = bbox
+
+
+########################################################################################################################
+
+
+class QGFFrameDataDescriptorV1:
+    type_id = 0x05
+
+    def __init__(self):
+        self.header = QGFBlockHeader()
+        self.header.type_id = QGFFrameDataDescriptorV1.type_id
+        self.data = []
+
+    def write(self, fp):
+        self.header.length = len(self.data)
+        self.header.write(fp)
+        fp.write(bytes(self.data))
+
+
+########################################################################################################################
+
+
+class QGFImageFile(ImageFile.ImageFile):
+
+    format = "QGF"
+    format_description = "Quantum Graphics File Format"
+
+    def _open(self):
+        raise NotImplementedError("Reading QGF files is not supported")
+
+
+########################################################################################################################
+
+
+def _accept(prefix):
+    """Helper method used by PIL to work out if it can parse an input file.
+
+    Currently unimplemented.
+    """
+    return False
+
+
+def _for_all_frames(x: FunctionType, /, images):
+    frame_num = 0
+    last_frame = None
+    for frame in images:
+        # Get number of of frames in this image
+        nfr = getattr(frame, "n_frames", 1)
+        for idx in range(nfr):
+            frame.seek(idx)
+            frame.load()
+            copy = frame.copy().convert("RGB")
+            x(frame_num, copy, last_frame)
+            last_frame = copy
+            frame_num += 1
+
+
+def _compress_image(frame, last_frame, *, use_rle, use_deltas, format_, **_kwargs):
+    # Convert the original frame so we can do comparisons
+    converted = qmk.painter.convert_requested_format(frame, format_)
+    graphic_data = qmk.painter.convert_image_bytes(converted, format_)
+
+    # Convert the raw data to RLE-encoded if requested
+    raw_data = graphic_data[1]
+    if use_rle:
+        rle_data = qmk.painter.compress_bytes_qmk_rle(graphic_data[1])
+    use_raw_this_frame = not use_rle or len(raw_data) <= len(rle_data)
+    image_data = raw_data if use_raw_this_frame else rle_data
+
+    # Work out if a delta frame is smaller than injecting it directly
+    use_delta_this_frame = False
+    bbox = None
+    if use_deltas and last_frame is not None:
+        # If we want to use deltas, then find the difference
+        diff = ImageChops.difference(frame, last_frame)
+
+        # Get the bounding box of those differences
+        bbox = diff.getbbox()
+
+        # If we have a valid bounding box...
+        if bbox:
+            # ...create the delta frame by cropping the original.
+            delta_frame = frame.crop(bbox)
+
+            # Convert the delta frame to the requested format
+            delta_converted = qmk.painter.convert_requested_format(delta_frame, format_)
+            delta_graphic_data = qmk.painter.convert_image_bytes(delta_converted, format_)
+
+            # Work out how large the delta frame is going to be with compression etc.
+            delta_raw_data = delta_graphic_data[1]
+            if use_rle:
+                delta_rle_data = qmk.painter.compress_bytes_qmk_rle(delta_graphic_data[1])
+            delta_use_raw_this_frame = not use_rle or len(delta_raw_data) <= len(delta_rle_data)
+            delta_image_data = delta_raw_data if delta_use_raw_this_frame else delta_rle_data
+
+            # If the size of the delta frame (plus delta descriptor) is smaller than the original, use that instead
+            # This ensures that if a non-delta is overall smaller in size, we use that in preference due to flash
+            # sizing constraints.
+            if (len(delta_image_data) + QGFFrameDeltaDescriptorV1.length) < len(image_data):
+                # Copy across all the delta equivalents so that the rest of the processing acts on those
+                graphic_data = delta_graphic_data
+                raw_data = delta_raw_data
+                rle_data = delta_rle_data
+                use_raw_this_frame = delta_use_raw_this_frame
+                image_data = delta_image_data
+                use_delta_this_frame = True
+
+        # Default to whole image
+        bbox = bbox or [0, 0, *frame.size]
+        # Fix sze (as per #20296), we need to cast first as tuples are inmutable
+        bbox = list(bbox)
+        bbox[2] -= 1
+        bbox[3] -= 1
+
+    return {
+        "bbox": bbox,
+        "graphic_data": graphic_data,
+        "image_data": image_data,
+        "use_delta_this_frame": use_delta_this_frame,
+        "use_raw_this_frame": use_raw_this_frame,
+    }
+
+
+# Helper function to save each frame to the output file
+def _write_frame(idx, frame, last_frame, *, fp, frame_offsets, metadata, **kwargs):
+    # Not an argument of the function as it would then not be part of kwargs
+    # This would cause an issue with `_compress_image(**kwargs)` missing an argument
+    format_ = kwargs["format_"]
+
+    # (potentially) Apply RLE and/or delta, and work out output image's information
+    outputs = _compress_image(frame, last_frame, **kwargs)
+    bbox = outputs["bbox"]
+    graphic_data = outputs["graphic_data"]
+    image_data = outputs["image_data"]
+    use_delta_this_frame = outputs["use_delta_this_frame"]
+    use_raw_this_frame = outputs["use_raw_this_frame"]
+
+    # Write out the frame descriptor
+    frame_offsets.frame_offsets[idx] = fp.tell()
+    vprint(f'{f"Frame {idx:3d} base":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+    frame_descriptor = QGFFrameDescriptorV1()
+    frame_descriptor.is_delta = use_delta_this_frame
+    frame_descriptor.is_transparent = False
+    frame_descriptor.format = format_['image_format_byte']
+    frame_descriptor.compression = 0x00 if use_raw_this_frame else 0x01  # See qp.h, painter_compression_t
+    frame_descriptor.delay = frame.info.get('duration', 1000)  # If we're not an animation, just pretend we're delaying for 1000ms
+    frame_descriptor.write(fp)
+
+    # Write out the palette if required
+    if format_['has_palette']:
+        palette = graphic_data[0]
+        palette_descriptor = QGFFramePaletteDescriptorV1()
+
+        # Convert all palette entries to HSV888 and write to the output
+        palette_descriptor.palette_entries = list(map(rgb888_to_qmk_hsv888, palette))
+        vprint(f'{f"Frame {idx:3d} palette":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+        palette_descriptor.write(fp)
+
+    # Write out the delta info if required
+    if use_delta_this_frame:
+        # Set up the rendering location of where the delta frame should be situated
+        delta_descriptor = QGFFrameDeltaDescriptorV1()
+        delta_descriptor.bbox = bbox
+
+        # Write the delta frame to the output
+        vprint(f'{f"Frame {idx:3d} delta":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+        delta_descriptor.write(fp)
+
+    # Store metadata, showed later in a comment in the generated file
+    frame_metadata = {
+        "compression": frame_descriptor.compression,
+        "delta": frame_descriptor.is_delta,
+        "delay": frame_descriptor.delay,
+    }
+    if frame_metadata["delta"]:
+        frame_metadata.update({"delta_rect": [
+            delta_descriptor.left,
+            delta_descriptor.top,
+            delta_descriptor.right,
+            delta_descriptor.bottom,
+        ]})
+    metadata.append(frame_metadata)
+
+    # Write out the data for this frame to the output
+    data_descriptor = QGFFrameDataDescriptorV1()
+    data_descriptor.data = image_data
+    vprint(f'{f"Frame {idx:3d} data":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+    data_descriptor.write(fp)
+
+
+def _save(im, fp, _filename):
+    """Helper method used by PIL to write to an output file.
+    """
+    # Work out from the parameters if we need to do anything special
+    encoderinfo = im.encoderinfo.copy()
+
+    # Store image file in metadata structure
+    metadata = encoderinfo.get("metadata", [])
+    metadata.append({"width": im.width, "height": im.height})
+
+    # Helper for prints, noop taking any args if not verbose
+    global vprint
+    verbose = encoderinfo.get("verbose", False)
+    vprint = print if verbose else lambda *_args, **_kwargs: None
+
+    # Helper to iterate through all frames in the input image
+    append_images = list(encoderinfo.get("append_images", []))
+    for_all_frames = functools.partial(_for_all_frames, images=[im, *append_images])
+
+    # Collect all the frame sizes
+    frame_sizes = []
+    for_all_frames(lambda _idx, frame, _last_frame: frame_sizes.append(frame.size))
+
+    # Make sure all frames are the same size
+    if len(set(frame_sizes)) != 1:
+        raise ValueError("Mismatching sizes on frames")
+
+    # Write out the initial graphics descriptor (and write a dummy value), so that we can come back and fill in the
+    # correct values once we've written all the frames to the output
+    graphics_descriptor_location = fp.tell()
+    graphics_descriptor = QGFGraphicsDescriptor()
+    graphics_descriptor.frame_count = len(frame_sizes)
+    graphics_descriptor.image_size = frame_sizes[0]
+    vprint(f'{"Graphics descriptor block":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+    graphics_descriptor.write(fp)
+
+    # Work out the frame offset descriptor location (and write a dummy value), so that we can come back and fill in the
+    # correct offsets once we've written all the frames to the output
+    frame_offset_location = fp.tell()
+    frame_offsets = QGFFrameOffsetDescriptorV1(graphics_descriptor.frame_count)
+    vprint(f'{"Frame offsets block":26s} {fp.tell():5d}d / {fp.tell():04X}h')
+    frame_offsets.write(fp)
+
+    # Iterate over each if the input frames, writing it to the output in the process
+    write_frame = functools.partial(_write_frame, format_=encoderinfo["qmk_format"], fp=fp, use_deltas=encoderinfo.get("use_deltas", True), use_rle=encoderinfo.get("use_rle", True), frame_offsets=frame_offsets, metadata=metadata)
+    for_all_frames(write_frame)
+
+    # Go back and update the graphics descriptor now that we can determine the final file size
+    graphics_descriptor.total_file_size = fp.tell()
+    fp.seek(graphics_descriptor_location, 0)
+    graphics_descriptor.write(fp)
+
+    # Go back and update the frame offsets now that they're written to the file
+    fp.seek(frame_offset_location, 0)
+    frame_offsets.write(fp)
+
+
+########################################################################################################################
+
+# Register with PIL so that it knows about the QGF format
+Image.register_open(QGFImageFile.format, QGFImageFile, _accept)
+Image.register_save(QGFImageFile.format, _save)
+Image.register_save_all(QGFImageFile.format, _save)
+Image.register_extension(QGFImageFile.format, f".{QGFImageFile.format.lower()}")
+Image.register_mime(QGFImageFile.format, f"image/{QGFImageFile.format.lower()}")
diff --git a/lib/python/qmk/path.py b/lib/python/qmk/path.py
new file mode 100644
index 0000000000..1739689adf
--- /dev/null
+++ b/lib/python/qmk/path.py
@@ -0,0 +1,181 @@
+"""Functions that help us work with files and folders.
+"""
+import logging
+import os
+import argparse
+from pathlib import Path, PureWindowsPath, PurePosixPath
+
+from qmk.constants import MAX_KEYBOARD_SUBFOLDERS, QMK_FIRMWARE, QMK_USERSPACE, HAS_QMK_USERSPACE
+from qmk.errors import NoSuchKeyboardError
+
+
+def is_keyboard(keyboard_name):
+    """Returns True if `keyboard_name` is a keyboard we can compile.
+    """
+    if not keyboard_name:
+        return False
+
+    # keyboard_name values of 'c:/something' or '/something' trigger append issues
+    # due to "If the argument is an absolute path, the previous path is ignored"
+    # however it should always be a folder located under qmk_firmware/keyboards
+    if Path(keyboard_name).is_absolute():
+        return False
+
+    keyboard_json = QMK_FIRMWARE / 'keyboards' / keyboard_name / 'keyboard.json'
+
+    return keyboard_json.exists()
+
+
+def under_qmk_firmware(path=Path(os.environ['ORIG_CWD'])):
+    """Returns a Path object representing the relative path under qmk_firmware, or None.
+    """
+    try:
+        return path.relative_to(QMK_FIRMWARE)
+    except ValueError:
+        return None
+
+
+def under_qmk_userspace(path=Path(os.environ['ORIG_CWD'])):
+    """Returns a Path object representing the relative path under $QMK_USERSPACE, or None.
+    """
+    try:
+        if HAS_QMK_USERSPACE:
+            return path.relative_to(QMK_USERSPACE)
+    except ValueError:
+        pass
+    return None
+
+
+def is_under_qmk_firmware(path=Path(os.environ['ORIG_CWD'])):
+    """Returns a boolean if the input path is a child under qmk_firmware.
+    """
+    if path is None:
+        return False
+    try:
+        return Path(os.path.commonpath([Path(path), QMK_FIRMWARE])) == QMK_FIRMWARE
+    except ValueError:
+        return False
+
+
+def is_under_qmk_userspace(path=Path(os.environ['ORIG_CWD'])):
+    """Returns a boolean if the input path is a child under $QMK_USERSPACE.
+    """
+    if path is None:
+        return False
+    try:
+        if HAS_QMK_USERSPACE:
+            return Path(os.path.commonpath([Path(path), QMK_USERSPACE])) == QMK_USERSPACE
+    except ValueError:
+        return False
+
+
+def keyboard(keyboard_name):
+    """Returns the path to a keyboard's directory relative to the qmk root.
+    """
+    return Path('keyboards') / keyboard_name
+
+
+def keymaps(keyboard_name):
+    """Returns all of the `keymaps/` directories for a given keyboard.
+
+    Args:
+
+        keyboard_name
+            The name of the keyboard. Example: clueboard/66/rev3
+    """
+    keyboard_folder = keyboard(keyboard_name)
+    found_dirs = []
+
+    if HAS_QMK_USERSPACE:
+        this_keyboard_folder = Path(QMK_USERSPACE) / keyboard_folder
+        for _ in range(MAX_KEYBOARD_SUBFOLDERS):
+            if (this_keyboard_folder / 'keymaps').exists():
+                found_dirs.append((this_keyboard_folder / 'keymaps').resolve())
+
+            this_keyboard_folder = this_keyboard_folder.parent
+            if this_keyboard_folder.resolve() == QMK_USERSPACE.resolve():
+                break
+
+        # We don't have any relevant keymap directories in userspace, so we'll use the fully-qualified path instead.
+        if len(found_dirs) == 0:
+            found_dirs.append((QMK_USERSPACE / keyboard_folder / 'keymaps').resolve())
+
+    this_keyboard_folder = QMK_FIRMWARE / keyboard_folder
+    for _ in range(MAX_KEYBOARD_SUBFOLDERS):
+        if (this_keyboard_folder / 'keymaps').exists():
+            found_dirs.append((this_keyboard_folder / 'keymaps').resolve())
+
+        this_keyboard_folder = this_keyboard_folder.parent
+        if this_keyboard_folder.resolve() == QMK_FIRMWARE.resolve():
+            break
+
+    if len(found_dirs) > 0:
+        return found_dirs
+
+    logging.error('Could not find the keymaps directory!')
+    raise NoSuchKeyboardError('Could not find keymaps directory for: %s' % keyboard_name)
+
+
+def keymap(keyboard_name, keymap_name):
+    """Locate the directory of a given keymap.
+
+    Args:
+
+        keyboard_name
+            The name of the keyboard. Example: clueboard/66/rev3
+        keymap_name
+            The name of the keymap. Example: default
+    """
+    for keymap_dir in keymaps(keyboard_name):
+        if (keymap_dir / keymap_name).exists():
+            return (keymap_dir / keymap_name).resolve()
+
+
+def normpath(path):
+    """Returns a `pathlib.Path()` object for a given path.
+
+    This will use the path to a file as seen from the directory the script was called from. You should use this to normalize filenames supplied from the command line.
+    """
+    path = Path(path)
+
+    if path.is_absolute():
+        return path
+
+    return Path(os.environ['ORIG_CWD']) / path
+
+
+def unix_style_path(path):
+    """Converts a Windows-style path with drive letter to a Unix path.
+
+    Path().as_posix() normally returns the path with drive letter and forward slashes, so is inappropriate for `Makefile` paths.
+
+    Passes through unadulterated if the path is not a Windows-style path.
+
+    Args:
+
+        path
+            The path to convert.
+
+    Returns:
+        The input path converted to Unix format.
+    """
+    if isinstance(path, PureWindowsPath):
+        p = list(path.parts)
+        p[0] = f'/{p[0][0].lower()}'  # convert from `X:/` to `/x`
+        path = PurePosixPath(*p)
+    return path
+
+
+class FileType(argparse.FileType):
+    def __init__(self, *args, **kwargs):
+        # Use UTF8 by default for stdin
+        if 'encoding' not in kwargs:
+            kwargs['encoding'] = 'UTF-8'
+        return super().__init__(*args, **kwargs)
+
+    def __call__(self, string):
+        """normalize and check exists
+            otherwise magic strings like '-' for stdin resolve to bad paths
+        """
+        norm = normpath(string)
+        return norm if norm.exists() else super().__call__(string)
diff --git a/lib/python/qmk/search.py b/lib/python/qmk/search.py
new file mode 100644
index 0000000000..c7bce344ad
--- /dev/null
+++ b/lib/python/qmk/search.py
@@ -0,0 +1,329 @@
+"""Functions for searching through QMK keyboards and keymaps.
+"""
+from dataclasses import dataclass
+import contextlib
+import functools
+import fnmatch
+import json
+import logging
+import re
+from typing import Callable, Dict, List, Optional, Tuple, Union
+from dotty_dict import dotty, Dotty
+from milc import cli
+
+from qmk.util import parallel_map
+from qmk.info import keymap_json
+from qmk.keyboard import list_keyboards, keyboard_folder
+from qmk.keymap import list_keymaps, locate_keymap
+from qmk.build_targets import KeyboardKeymapBuildTarget, BuildTarget
+
+
+@dataclass
+class KeyboardKeymapDesc:
+    keyboard: str
+    keymap: str
+    data: dict = None
+    extra_args: dict = None
+
+    def __hash__(self) -> int:
+        return self.keyboard.__hash__() ^ self.keymap.__hash__() ^ json.dumps(self.extra_args, sort_keys=True).__hash__()
+
+    def __lt__(self, other) -> bool:
+        return (self.keyboard, self.keymap, json.dumps(self.extra_args, sort_keys=True)) < (other.keyboard, other.keymap, json.dumps(other.extra_args, sort_keys=True))
+
+    def load_data(self):
+        data = keymap_json(self.keyboard, self.keymap)
+        self.data = data.to_dict() if isinstance(data, Dotty) else data
+
+    @property
+    def dotty(self) -> Dotty:
+        return dotty(self.data) if self.data is not None else None
+
+    def to_build_target(self) -> KeyboardKeymapBuildTarget:
+        target = KeyboardKeymapBuildTarget(keyboard=self.keyboard, keymap=self.keymap, json=self.data)
+        target.extra_args = self.extra_args
+        return target
+
+
+# by using a class for filters, we dont need to worry about capturing values
+# see details <https://github.com/qmk/qmk_firmware/pull/21090>
+class FilterFunction:
+    """Base class for filters.
+    It provides:
+        - __init__: capture key and value
+
+    Each subclass should provide:
+        - func_name: how it will be specified on CLI
+            >>> qmk find -f <func_name>...
+        - apply: function that actually applies the filter
+            ie: return whether the input kb/km satisfies the condition
+    """
+
+    key: str
+    value: Optional[str]
+
+    func_name: str
+    apply: Callable[[KeyboardKeymapDesc], bool]
+
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+
+
+class Exists(FilterFunction):
+    func_name = "exists"
+
+    def apply(self, target_info: KeyboardKeymapDesc) -> bool:
+        return self.key in target_info.dotty
+
+
+class Absent(FilterFunction):
+    func_name = "absent"
+
+    def apply(self, target_info: KeyboardKeymapDesc) -> bool:
+        return self.key not in target_info.dotty
+
+
+class Length(FilterFunction):
+    func_name = "length"
+
+    def apply(self, target_info: KeyboardKeymapDesc) -> bool:
+        info_dotty = target_info.dotty
+        return (self.key in info_dotty and len(info_dotty[self.key]) == int(self.value))
+
+
+class Contains(FilterFunction):
+    func_name = "contains"
+
+    def apply(self, target_info: KeyboardKeymapDesc) -> bool:
+        info_dotty = target_info.dotty
+        return (self.key in info_dotty and self.value in info_dotty[self.key])
+
+
+def _get_filter_class(func_name: str, key: str, value: str) -> Optional[FilterFunction]:
+    """Initialize a filter subclass based on regex findings and return it.
+    None if no there's no filter with the name queried.
+    """
+
+    for subclass in FilterFunction.__subclasses__():
+        if func_name == subclass.func_name:
+            return subclass(key, value)
+
+    return None
+
+
+def filter_help() -> str:
+    names = [f"'{f.func_name}'" for f in FilterFunction.__subclasses__()]
+    return ", ".join(names[:-1]) + f" and {names[-1]}"
+
+
+def _set_log_level(level):
+    cli.acquire_lock()
+    try:
+        old = cli.log_level
+        cli.log_level = level
+    except AttributeError:
+        old = cli.log.level
+    cli.log.setLevel(level)
+    logging.root.setLevel(level)
+    cli.release_lock()
+    return old
+
+
+@contextlib.contextmanager
+def ignore_logging():
+    old = _set_log_level(logging.CRITICAL)
+    yield
+    _set_log_level(old)
+
+
+def _all_keymaps(keyboard) -> List[KeyboardKeymapDesc]:
+    """Returns a list of KeyboardKeymapDesc for all keymaps for the given keyboard.
+    """
+    with ignore_logging():
+        keyboard = keyboard_folder(keyboard)
+        return [KeyboardKeymapDesc(keyboard, keymap) for keymap in list_keymaps(keyboard)]
+
+
+def _keymap_exists(keyboard, keymap):
+    """Returns the keyboard name if the keyboard+keymap combination exists, otherwise None.
+    """
+    with ignore_logging():
+        return keyboard if locate_keymap(keyboard, keymap) is not None else None
+
+
+def _load_keymap_info(target: KeyboardKeymapDesc) -> KeyboardKeymapDesc:
+    """Ensures a KeyboardKeymapDesc has its data loaded.
+    """
+    with ignore_logging():
+        target.load_data()  # Ensure we load the data first
+        return target
+
+
+def expand_make_targets(targets: List[Union[str, Tuple[str, Dict[str, str]]]]) -> List[KeyboardKeymapDesc]:
+    """Expand a list of make targets into a list of KeyboardKeymapDesc.
+
+    Caters for 'all' in either keyboard or keymap, or both.
+    """
+    split_targets = []
+    for target in targets:
+        extra_args = None
+        if isinstance(target, tuple):
+            split_target = target[0].split(':')
+            extra_args = target[1]
+        else:
+            split_target = target.split(':')
+        if len(split_target) != 2:
+            cli.log.error(f"Invalid build target: {target}")
+            return []
+        split_targets.append(KeyboardKeymapDesc(split_target[0], split_target[1], extra_args=extra_args))
+    return expand_keymap_targets(split_targets)
+
+
+def _expand_keymap_target(target: KeyboardKeymapDesc, all_keyboards: List[str] = None) -> List[KeyboardKeymapDesc]:
+    """Expand a keyboard input and keymap input into a list of KeyboardKeymapDesc.
+
+    Caters for 'all' in either keyboard or keymap, or both.
+    """
+    if all_keyboards is None:
+        all_keyboards = list_keyboards()
+
+    if target.keyboard == 'all':
+        if target.keymap == 'all':
+            cli.log.info('Retrieving list of all keyboards and keymaps...')
+            targets = []
+            for kb in parallel_map(_all_keymaps, all_keyboards):
+                targets.extend(kb)
+            for t in targets:
+                t.extra_args = target.extra_args
+            return targets
+        else:
+            cli.log.info(f'Retrieving list of keyboards with keymap "{target.keymap}"...')
+            keyboard_filter = functools.partial(_keymap_exists, keymap=target.keymap)
+            return [KeyboardKeymapDesc(kb, target.keymap, extra_args=target.extra_args) for kb in filter(lambda e: e is not None, parallel_map(keyboard_filter, all_keyboards))]
+    else:
+        if target.keymap == 'all':
+            cli.log.info(f'Retrieving list of keymaps for keyboard "{target.keyboard}"...')
+            targets = _all_keymaps(target.keyboard)
+            for t in targets:
+                t.extra_args = target.extra_args
+            return targets
+        else:
+            return [target]
+
+
+def expand_keymap_targets(targets: List[KeyboardKeymapDesc]) -> List[KeyboardKeymapDesc]:
+    """Expand a list of KeyboardKeymapDesc inclusive of 'all', into a list of explicit KeyboardKeymapDesc.
+    """
+    overall_targets = []
+    all_keyboards = list_keyboards()
+    for target in targets:
+        overall_targets.extend(_expand_keymap_target(target, all_keyboards))
+    return list(sorted(set(overall_targets)))
+
+
+def _construct_build_target(e: KeyboardKeymapDesc):
+    return e.to_build_target()
+
+
+def _filter_keymap_targets(target_list: List[KeyboardKeymapDesc], filters: List[str] = []) -> List[KeyboardKeymapDesc]:
+    """Filter a list of KeyboardKeymapDesc based on the supplied filters.
+
+    Optionally includes the values of the queried info.json keys.
+    """
+    if len(filters) == 0:
+        cli.log.info('Preparing target list...')
+        targets = target_list
+    else:
+        cli.log.info('Parsing data for all matching keyboard/keymap combinations...')
+        valid_targets = parallel_map(_load_keymap_info, target_list)
+
+        function_re = re.compile(r'^(?P<function>[a-zA-Z]+)\((?P<key>[a-zA-Z0-9_\.]+)(,\s*(?P<value>[^#]+))?\)$')
+        comparison_re = re.compile(r'^(?P<key>[a-zA-Z0-9_\.]+)\s*(?P<op>[\<\>\!=]=|\<|\>)\s*(?P<value>[^#]+)$')
+
+        for filter_expr in filters:
+            function_match = function_re.match(filter_expr)
+            comparison_match = comparison_re.match(filter_expr)
+
+            if function_match is not None:
+                func_name = function_match.group('function').lower()
+                key = function_match.group('key')
+                value = function_match.group('value')
+
+                filter_class = _get_filter_class(func_name, key, value)
+                if filter_class is None:
+                    cli.log.warning(f'Unrecognized filter expression: {function_match.group(0)}')
+                    continue
+                valid_targets = filter(filter_class.apply, valid_targets)
+
+                value_str = f", {{fg_cyan}}{value}{{fg_reset}}" if value is not None else ""
+                cli.log.info(f'Filtering on condition: {{fg_green}}{func_name}{{fg_reset}}({{fg_cyan}}{key}{{fg_reset}}{value_str})...')
+
+            elif comparison_match is not None:
+                key = comparison_match.group('key')
+                op = comparison_match.group('op')
+                value = comparison_match.group('value')
+                cli.log.info(f'Filtering on condition: {{fg_cyan}}{key}{{fg_reset}} {op} {{fg_cyan}}{value}{{fg_reset}}...')
+
+                def _make_filter(k, o, v):
+                    expr = fnmatch.translate(v)
+                    rule = re.compile(f'^{expr}$', re.IGNORECASE)
+
+                    def f(e: KeyboardKeymapDesc):
+                        lhs = e.dotty.get(k)
+                        rhs = v
+
+                        if o in ['<', '>', '<=', '>=']:
+                            lhs = int(False if lhs is None else lhs)
+                            rhs = int(rhs)
+
+                            if o == '<':
+                                return lhs < rhs
+                            elif o == '>':
+                                return lhs > rhs
+                            elif o == '<=':
+                                return lhs <= rhs
+                            elif o == '>=':
+                                return lhs >= rhs
+                        else:
+                            lhs = str(False if lhs is None else lhs)
+
+                            if o == '!=':
+                                return rule.search(lhs) is None
+                            elif o == '==':
+                                return rule.search(lhs) is not None
+
+                    return f
+
+                valid_targets = filter(_make_filter(key, op, value), valid_targets)
+            else:
+                cli.log.warning(f'Unrecognized filter expression: {filter_expr}')
+                continue
+
+        cli.log.info('Preparing target list...')
+        targets = list(sorted(set(valid_targets)))
+
+    return targets
+
+
+def search_keymap_targets(targets: List[Union[Tuple[str, str], Tuple[str, str, Dict[str, str]]]] = [('all', 'default')], filters: List[str] = []) -> List[BuildTarget]:
+    """Search for build targets matching the supplied criteria.
+    """
+    def _make_desc(e):
+        if len(e) == 3:
+            return KeyboardKeymapDesc(keyboard=e[0], keymap=e[1], extra_args=e[2])
+        else:
+            return KeyboardKeymapDesc(keyboard=e[0], keymap=e[1])
+
+    targets = map(_make_desc, targets)
+    targets = _filter_keymap_targets(expand_keymap_targets(targets), filters)
+    targets = list(set(parallel_map(_construct_build_target, list(targets))))
+    return sorted(targets)
+
+
+def search_make_targets(targets: List[Union[str, Tuple[str, Dict[str, str]]]], filters: List[str] = []) -> List[BuildTarget]:
+    """Search for build targets matching the supplied criteria.
+    """
+    targets = _filter_keymap_targets(expand_make_targets(targets), filters)
+    targets = list(set(parallel_map(_construct_build_target, list(targets))))
+    return sorted(targets)
diff --git a/lib/python/qmk/submodules.py b/lib/python/qmk/submodules.py
new file mode 100644
index 0000000000..d0050b371d
--- /dev/null
+++ b/lib/python/qmk/submodules.py
@@ -0,0 +1,90 @@
+"""Functions for working with QMK's submodules.
+"""
+from milc import cli
+
+
+def status():
+    """Returns a dictionary of submodules.
+
+    Each entry is a dict of the form:
+
+        {
+            'name': 'submodule_name',
+            'status': None/False/True,
+            'githash': '<sha-1 hash for the submodule>'
+            'shorthash': '<short hash for the submodule>'
+            'describe': '<output of `git describe --tags`>'
+            'last_log_message': 'log message'
+            'last_log_timestamp': 'timestamp'
+        }
+
+    status is None when the submodule doesn't exist, False when it's out of date, and True when it's current
+    """
+    submodules = {}
+    gitmodule_config = cli.run(['git', 'config', '-f', '.gitmodules', '-l'], timeout=30)
+    for line in gitmodule_config.stdout.splitlines():
+        key, value = line.split('=', maxsplit=2)
+        if key.endswith('.path'):
+            submodules[value] = {'name': value, 'status': None}
+
+    git_cmd = cli.run(['git', 'submodule', 'status'], timeout=30)
+    for line in git_cmd.stdout.splitlines():
+        status = line[0]
+        githash, submodule = line[1:].split()[:2]
+        submodules[submodule]['githash'] = githash
+
+        if status == '-':
+            submodules[submodule]['status'] = None
+        elif status == '+':
+            submodules[submodule]['status'] = False
+        elif status == ' ':
+            submodules[submodule]['status'] = True
+        else:
+            raise ValueError('Unknown `git submodule status` sha-1 prefix character: "%s"' % status)
+
+    submodule_logs = cli.run(['git', 'submodule', '-q', 'foreach', 'git --no-pager log --no-show-signature --pretty=format:"$sm_path%x01%h%x01%ad%x01%s%x0A" --date=iso -n1'])
+    for log_line in submodule_logs.stdout.splitlines():
+        r = log_line.split('\x01')
+        submodule = r[0]
+        submodules[submodule]['shorthash'] = r[1] if len(r) > 1 else ''
+        submodules[submodule]['last_log_timestamp'] = r[2] if len(r) > 2 else ''
+        submodules[submodule]['last_log_message'] = r[3] if len(r) > 3 else ''
+
+    submodule_tags = cli.run(['git', 'submodule', '-q', 'foreach', '\'echo $sm_path `git describe --tags`\''])
+    for log_line in submodule_tags.stdout.splitlines():
+        r = log_line.split()
+        submodule = r[0]
+        submodules[submodule]['describe'] = r[1] if len(r) > 1 else ''
+
+    return submodules
+
+
+def update(submodules=None):
+    """Update the submodules.
+
+        submodules
+            A string containing a single submodule or a list of submodules.
+    """
+    git_sync_cmd = ['git', 'submodule', 'sync']
+    git_update_cmd = ['git', 'submodule', 'update', '--init']
+
+    if submodules is None:
+        # Update everything
+        git_sync_cmd.append('--recursive')
+        git_update_cmd.append('--recursive')
+        cli.run(git_sync_cmd, check=True)
+        cli.run(git_update_cmd, check=True)
+
+    else:
+        if isinstance(submodules, str):
+            # Update only a single submodule
+            git_sync_cmd.append(submodules)
+            git_update_cmd.append(submodules)
+            cli.run(git_sync_cmd, check=True)
+            cli.run(git_update_cmd, check=True)
+
+        else:
+            # Update submodules in a list
+            for submodule in submodules:
+                cli.run([*git_sync_cmd, submodule], check=True)
+                cli.run([*git_update_cmd, submodule], check=True)
diff --git a/lib/python/qmk/tests/.gitignore b/lib/python/qmk/tests/.gitignore
new file mode 100644
index 0000000000..eeb6581b87
--- /dev/null
+++ b/lib/python/qmk/tests/.gitignore
@@ -0,0 +1,2 @@
+# Ignore generated info.json from pytest
+info.json
diff --git a/lib/python/qmk/tests/__init__.py b/lib/python/qmk/tests/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/python/qmk/tests/__init__.py
diff --git a/lib/python/qmk/tests/attrdict.py b/lib/python/qmk/tests/attrdict.py
new file mode 100644
index 0000000000..a2584b9233
--- /dev/null
+++ b/lib/python/qmk/tests/attrdict.py
@@ -0,0 +1,8 @@
+class AttrDict(dict):
+    """A dictionary that can be accessed by attributes.
+
+    This should only be used to mock objects for unit testing. Please do not use this outside of qmk.tests.
+    """
+    def __init__(self, *args, **kwargs):
+        super(AttrDict, self).__init__(*args, **kwargs)
+        self.__dict__ = self
diff --git a/lib/python/qmk/tests/kle.txt b/lib/python/qmk/tests/kle.txt
new file mode 100644
index 0000000000..862a899ab9
--- /dev/null
+++ b/lib/python/qmk/tests/kle.txt
@@ -0,0 +1,5 @@
+["¬\n`","!\n1","\"\n2","£\n3","$\n4","%\n5","^\n6","&\n7","*\n8","(\n9",")\n0","_\n-","+\n=",{w:2},"Backspace"],
+[{w:1.5},"Tab","Q","W","E","R","T","Y","U","I","O","P","{\n[","}\n]",{x:0.25,w:1.25,h:2,w2:1.5,h2:1,x2:-0.25},"Enter"],
+[{w:1.75},"Caps Lock","A","S","D","F","G","H","J","K","L",":\n;","@\n'","~\n#"],
+[{w:1.25},"Shift","|\n\\","Z","X","C","V","B","N","M","<\n,",">\n.","?\n/",{w:2.75},"Shift"],
+[{w:1.25},"Ctrl",{w:1.25},"Win",{w:1.25},"Alt",{a:7,w:6.25},"",{a:4,w:1.25},"AltGr",{w:1.25},"Win",{w:1.25},"Menu",{w:1.25},"Ctrl"]
diff --git a/lib/python/qmk/tests/minimal_info.json b/lib/python/qmk/tests/minimal_info.json
new file mode 100644
index 0000000000..7f5ec1f983
--- /dev/null
+++ b/lib/python/qmk/tests/minimal_info.json
@@ -0,0 +1,11 @@
+{
+    "keyboard_name": "tester",
+    "maintainer": "qmk",
+    "layouts": {
+        "LAYOUT": {
+            "layout": [
+                {"label": "KC_A", "matrix": [0, 0], "x": 0, "y": 0}
+            ]
+        }
+    }
+}
diff --git a/lib/python/qmk/tests/minimal_keymap.json b/lib/python/qmk/tests/minimal_keymap.json
new file mode 100644
index 0000000000..258f9e8a9a
--- /dev/null
+++ b/lib/python/qmk/tests/minimal_keymap.json
@@ -0,0 +1,7 @@
+{
+    "keyboard": "handwired/pytest/basic",
+    "keymap": "test",
+    "layers": [["KC_A"]],
+    "layout": "LAYOUT_ortho_1x1",
+    "version": 1
+}
diff --git a/lib/python/qmk/tests/test_cli_commands.py b/lib/python/qmk/tests/test_cli_commands.py
new file mode 100644
index 0000000000..2716459989
--- /dev/null
+++ b/lib/python/qmk/tests/test_cli_commands.py
@@ -0,0 +1,408 @@
+import platform
+from subprocess import DEVNULL
+
+from milc import cli
+
+is_windows = 'windows' in platform.platform().lower()
+
+
+def check_subcommand(command, *args):
+    cmd = ['qmk', command, *args]
+    result = cli.run(cmd, stdin=DEVNULL, combined_output=True)
+    return result
+
+
+def check_subcommand_stdin(file_to_read, command, *args):
+    """Pipe content of a file to a command and return output.
+    """
+    with open(file_to_read, encoding='utf-8') as my_file:
+        cmd = ['qmk', command, *args]
+        result = cli.run(cmd, stdin=my_file, combined_output=True)
+    return result
+
+
+def check_returncode(result, expected=[0]):
+    """Print stdout if `result.returncode` does not match `expected`.
+    """
+    if result.returncode not in expected:
+        print('`%s` stdout:' % ' '.join(result.args))
+        print(result.stdout)
+        print('returncode:', result.returncode)
+    assert result.returncode in expected
+
+
+def test_format_c():
+    result = check_subcommand('format-c', '-n', 'quantum/matrix.c')
+    check_returncode(result)
+
+
+def test_format_c_all():
+    result = check_subcommand('format-c', '-n', '-a')
+    check_returncode(result, [0, 1])
+
+
+def test_compile():
+    result = check_subcommand('compile', '-kb', 'handwired/pytest/basic', '-km', 'default', '-n')
+    check_returncode(result)
+
+
+def test_compile_json():
+    result = check_subcommand('compile', '-kb', 'handwired/pytest/basic', '-km', 'default_json', '-n')
+    check_returncode(result)
+
+
+def test_flash():
+    result = check_subcommand('flash', '-kb', 'handwired/pytest/basic', '-km', 'default', '-n')
+    check_returncode(result)
+
+
+def test_flash_bootloaders():
+    result = check_subcommand('flash', '-b')
+    check_returncode(result, [1])
+
+
+def test_kle2json():
+    result = check_subcommand('kle2json', 'lib/python/qmk/tests/kle.txt', '-f')
+    check_returncode(result)
+    assert 'Wrote out' in result.stdout
+
+
+def test_doctor():
+    result = check_subcommand('doctor', '-n')
+    check_returncode(result, [0, 1])
+    assert 'QMK Doctor is checking your environment.' in result.stdout
+    assert 'QMK is ready to go' in result.stdout
+
+
+def test_hello():
+    result = check_subcommand('hello')
+    check_returncode(result)
+    assert 'Hello,' in result.stdout
+
+
+def test_format_python():
+    result = check_subcommand('format-python', '-n', '-a')
+    check_returncode(result)
+    assert 'Successfully formatted the python code.' in result.stdout
+
+
+def test_list_keyboards():
+    result = check_subcommand('list-keyboards')
+    check_returncode(result)
+    # check to see if a known keyboard is returned
+    # this will fail if handwired/pytest/basic is removed
+    assert 'handwired/pytest/basic' in result.stdout
+
+
+def test_list_keymaps():
+    result = check_subcommand('list-keymaps', '-kb', 'handwired/pytest/basic')
+    check_returncode(result)
+    assert 'default' in result.stdout
+    assert 'default_json' in result.stdout
+
+
+def test_list_keymaps_long():
+    result = check_subcommand('list-keymaps', '--keyboard', 'handwired/pytest/basic')
+    check_returncode(result)
+    assert 'default' in result.stdout
+    assert 'default_json' in result.stdout
+
+
+def test_list_keymaps_community():
+    result = check_subcommand('list-keymaps', '--keyboard', 'handwired/pytest/has_community')
+    check_returncode(result)
+    assert 'test' in result.stdout
+
+
+def test_list_keymaps_kb_only():
+    result = check_subcommand('list-keymaps', '-kb', 'contra')
+    check_returncode(result)
+    assert 'default' in result.stdout
+
+
+def test_list_keymaps_vendor_kb():
+    result = check_subcommand('list-keymaps', '-kb', 'ai03/lunar')
+    check_returncode(result)
+    assert 'default' in result.stdout
+
+
+def test_list_keymaps_vendor_kb_rev():
+    result = check_subcommand('list-keymaps', '-kb', 'kbdfans/kbd67/mkiirgb/v2')
+    check_returncode(result)
+    assert 'default' in result.stdout
+
+
+def test_list_keymaps_no_keyboard_found():
+    result = check_subcommand('list-keymaps', '-kb', 'asdfghjkl')
+    check_returncode(result, [2])
+    assert 'invalid keyboard_folder value' in result.stdout
+
+
+def test_json2c():
+    result = check_subcommand('json2c', 'keyboards/handwired/pytest/basic/keymaps/default_json/keymap.json')
+    check_returncode(result)
+    assert result.stdout == """#include QMK_KEYBOARD_H
+#if __has_include("keymap.h")
+#    include "keymap.h"
+#endif
+
+
+/* THIS FILE WAS GENERATED!
+ *
+ * This file was generated by qmk json2c. You may or may not want to
+ * edit it directly.
+ */
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [0] = LAYOUT_ortho_1x1(KC_A)
+};
+
+
+
+
+#ifdef OTHER_KEYMAP_C
+#    include OTHER_KEYMAP_C
+#endif // OTHER_KEYMAP_C
+
+
+"""
+
+
+def test_json2c_macros():
+    result = check_subcommand("json2c", 'keyboards/handwired/pytest/macro/keymaps/default/keymap.json')
+    check_returncode(result)
+    assert 'LAYOUT_ortho_1x1(QK_MACRO_0)' in result.stdout
+    assert 'case QK_MACRO_0:' in result.stdout
+    assert 'SEND_STRING("Hello, World!"SS_TAP(X_ENTER));' in result.stdout
+
+
+def test_json2c_stdin():
+    result = check_subcommand_stdin('keyboards/handwired/pytest/basic/keymaps/default_json/keymap.json', 'json2c', '-')
+    check_returncode(result)
+    assert result.stdout == """#include QMK_KEYBOARD_H
+#if __has_include("keymap.h")
+#    include "keymap.h"
+#endif
+
+
+/* THIS FILE WAS GENERATED!
+ *
+ * This file was generated by qmk json2c. You may or may not want to
+ * edit it directly.
+ */
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [0] = LAYOUT_ortho_1x1(KC_A)
+};
+
+
+
+
+#ifdef OTHER_KEYMAP_C
+#    include OTHER_KEYMAP_C
+#endif // OTHER_KEYMAP_C
+
+
+"""
+
+
+def test_json2c_no_json():
+    result = check_subcommand('json2c', 'keyboards/handwired/pytest/basic/keymaps/default/keymap.c')
+    check_returncode(result, [1])
+    assert 'Invalid JSON encountered' in result.stdout
+
+
+def test_info():
+    result = check_subcommand('info', '-kb', 'handwired/pytest/basic')
+    check_returncode(result)
+    assert 'Keyboard Name: pytest' in result.stdout
+    assert 'Processor: atmega32u4' in result.stdout
+    assert 'Layout:' not in result.stdout
+    assert 'k0' not in result.stdout
+
+
+def test_info_keyboard_render():
+    result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-l')
+    check_returncode(result)
+    assert 'Keyboard Name: pytest' in result.stdout
+    assert 'Processor: atmega32u4' in result.stdout
+    assert 'Layouts:' in result.stdout
+
+    if is_windows:
+        assert '|  |' in result.stdout
+    else:
+        assert '│  │' in result.stdout
+
+
+def test_info_keymap_render():
+    result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-km', 'default_json')
+    check_returncode(result)
+    assert 'Keyboard Name: pytest' in result.stdout
+    assert 'Processor: atmega32u4' in result.stdout
+
+    if is_windows:
+        assert '|A |' in result.stdout
+    else:
+        assert '│A │' in result.stdout
+
+
+def test_info_matrix_render():
+    result = check_subcommand('info', '-kb', 'handwired/pytest/basic', '-m')
+    check_returncode(result)
+    assert 'Keyboard Name: pytest' in result.stdout
+    assert 'Processor: atmega32u4' in result.stdout
+    assert 'LAYOUT_ortho_1x1' in result.stdout
+
+    if is_windows:
+        assert '|0A|' in result.stdout
+    else:
+        assert '│0A│' in result.stdout
+
+    assert 'Matrix for "LAYOUT_ortho_1x1"' in result.stdout
+
+
+def test_c2json():
+    result = check_subcommand("c2json", "-kb", "handwired/pytest/basic", "-km", "default", "keyboards/handwired/pytest/basic/keymaps/default/keymap.c")
+    check_returncode(result)
+    assert result.stdout.strip() == '{"keyboard": "handwired/pytest/basic", "keymap": "default", "layout": "LAYOUT_ortho_1x1", "layers": [["KC_A"]]}'
+
+
+def test_c2json_stdin():
+    result = check_subcommand_stdin("keyboards/handwired/pytest/basic/keymaps/default/keymap.c", "c2json", "-kb", "handwired/pytest/basic", "-km", "default", "-")
+    check_returncode(result)
+    assert result.stdout.strip() == '{"keyboard": "handwired/pytest/basic", "keymap": "default", "layout": "LAYOUT_ortho_1x1", "layers": [["KC_A"]]}'
+
+
+def test_clean():
+    result = check_subcommand('clean', '-a')
+    check_returncode(result)
+    assert (result.stdout.count('done') == 2 and 'userspace' not in result.stdout) or (result.stdout.count('done') == 3 and 'userspace' in result.stdout)
+
+
+def test_generate_api():
+    result = check_subcommand('generate-api', '--dry-run', '--filter', 'handwired/pytest')
+    check_returncode(result)
+
+
+def test_generate_rgb_breathe_table():
+    result = check_subcommand("generate-rgb-breathe-table", "-c", "1.2", "-m", "127")
+    check_returncode(result)
+    assert 'Breathing center: 1.2' in result.stdout
+    assert 'Breathing max:    127' in result.stdout
+
+
+def test_generate_config_h():
+    result = check_subcommand('generate-config-h', '-kb', 'handwired/pytest/basic')
+    check_returncode(result)
+    assert '#    define DEVICE_VER 0x0001' in result.stdout
+    assert '#    define DIODE_DIRECTION COL2ROW' in result.stdout
+    assert '#    define MANUFACTURER "none"' in result.stdout
+    assert '#    define PRODUCT "pytest"' in result.stdout
+    assert '#    define PRODUCT_ID 0x6465' in result.stdout
+    assert '#    define VENDOR_ID 0xFEED' in result.stdout
+    assert '#    define MATRIX_COLS 1' in result.stdout
+    assert '#    define MATRIX_COL_PINS { F4 }' in result.stdout
+    assert '#    define MATRIX_ROWS 1' in result.stdout
+    assert '#    define MATRIX_ROW_PINS { F5 }' in result.stdout
+
+
+def test_generate_rules_mk():
+    result = check_subcommand('generate-rules-mk', '-kb', 'handwired/pytest/basic')
+    check_returncode(result)
+    assert 'BOOTLOADER ?= atmel-dfu' in result.stdout
+    assert 'MCU ?= atmega32u4' in result.stdout
+
+
+def test_generate_version_h():
+    result = check_subcommand('generate-version-h')
+    check_returncode(result)
+    assert '#define QMK_VERSION' in result.stdout
+
+
+def test_format_json_keyboard():
+    result = check_subcommand('format-json', '--format', 'keyboard', 'lib/python/qmk/tests/minimal_info.json')
+    check_returncode(result)
+    assert result.stdout == '{\n    "keyboard_name": "tester",\n    "maintainer": "qmk",\n    "layouts": {\n        "LAYOUT": {\n            "layout": [\n                {"label": "KC_A", "matrix": [0, 0], "x": 0, "y": 0}\n            ]\n        }\n    }\n}\n'
+
+
+def test_format_json_keymap():
+    result = check_subcommand('format-json', '--format', 'keymap', 'lib/python/qmk/tests/minimal_keymap.json')
+    check_returncode(result)
+    assert result.stdout == '{\n    "version": 1,\n    "keyboard": "handwired/pytest/basic",\n    "keymap": "test",\n    "layout": "LAYOUT_ortho_1x1",\n    "layers": [\n                [\n                        "KC_A"\n                ]\n    ]\n}\n'
+
+
+def test_format_json_keyboard_auto():
+    result = check_subcommand('format-json', '--format', 'auto', 'lib/python/qmk/tests/minimal_info.json')
+    check_returncode(result)
+    assert result.stdout == '{\n    "keyboard_name": "tester",\n    "maintainer": "qmk",\n    "layouts": {\n        "LAYOUT": {\n            "layout": [\n                {"label": "KC_A", "matrix": [0, 0], "x": 0, "y": 0}\n            ]\n        }\n    }\n}\n'
+
+
+def test_format_json_keymap_auto():
+    result = check_subcommand('format-json', '--format', 'auto', 'lib/python/qmk/tests/minimal_keymap.json')
+    check_returncode(result)
+    assert result.stdout == '{\n    "keyboard": "handwired/pytest/basic",\n    "keymap": "test",\n    "layers": [\n        ["KC_A"]\n    ],\n    "layout": "LAYOUT_ortho_1x1",\n    "version": 1\n}\n'
+
+
+def test_find_exists():
+    result = check_subcommand('find', '-f', 'exists(rgb_matrix.split_count)', '-p', 'rgb_matrix.split_count')
+    check_returncode(result)
+    values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
+    assert len(values) > 0
+    for s in values:
+        assert '=None' not in s
+        assert '=[' in s
+
+
+def test_find_absent():
+    result = check_subcommand('find', '-f', 'absent(rgb_matrix.split_count)', '-p', 'rgb_matrix.split_count')
+    check_returncode(result)
+    values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
+    assert len(values) > 0
+    for s in values:
+        assert '=None' in s
+        assert '=[' not in s
+
+
+def test_find_length():
+    result = check_subcommand('find', '-f', 'length(matrix_pins.cols, 6)', '-p', 'matrix_pins.cols')
+    check_returncode(result)
+    values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
+    assert len(values) > 0
+    for s in values:
+        assert s.count(',') == 5
+
+
+def test_find_contains():
+    result = check_subcommand('find', '-f', 'contains(matrix_pins.cols, B1)', '-p', 'matrix_pins.cols')
+    check_returncode(result)
+    values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
+    assert len(values) > 0
+    for s in values:
+        assert "'B1'" in s
+
+
+def test_find_multiple_conditions():
+    # this is intended to match at least 'crkbd/rev1'
+    result = check_subcommand(
+        'find', '-f', 'exists(rgb_matrix.split_count)', '-f', 'contains(matrix_pins.cols, B1)', '-f', 'length(matrix_pins.cols, 6)', '-f', 'absent(eeprom.driver)', '-f', 'ws2812.pin == D3', '-p', 'rgb_matrix.split_count', '-p', 'matrix_pins.cols', '-p',
+        'eeprom.driver', '-p', 'ws2812.pin'
+    )
+    check_returncode(result)
+    rgb_matrix_split_count_values = [s for s in result.stdout.splitlines() if 'rgb_matrix.split_count=' in s]
+    assert len(rgb_matrix_split_count_values) > 0
+    for s in rgb_matrix_split_count_values:
+        assert '=None' not in s
+        assert '=[' in s
+    matrix_pins_cols_values = [s for s in result.stdout.splitlines() if 'matrix_pins.cols=' in s]
+    assert len(matrix_pins_cols_values) > 0
+    for s in matrix_pins_cols_values:
+        assert s.count(',') == 5
+        assert "'B1'" in s
+    eeprom_driver_values = [s for s in result.stdout.splitlines() if 'eeprom.driver=' in s]
+    assert len(eeprom_driver_values) > 0
+    for s in eeprom_driver_values:
+        assert '=None' in s
+    ws2812_pin_values = [s for s in result.stdout.splitlines() if 'ws2812.pin=' in s]
+    assert len(ws2812_pin_values) > 0
+    for s in ws2812_pin_values:
+        assert '=D3' in s
diff --git a/lib/python/qmk/tests/test_qmk_errors.py b/lib/python/qmk/tests/test_qmk_errors.py
new file mode 100644
index 0000000000..948e7ef741
--- /dev/null
+++ b/lib/python/qmk/tests/test_qmk_errors.py
@@ -0,0 +1,8 @@
+from qmk.errors import NoSuchKeyboardError
+
+
+def test_nosuchkeyboarderror():
+    try:
+        raise NoSuchKeyboardError("test message")
+    except NoSuchKeyboardError as e:
+        assert e.message == 'test message'
diff --git a/lib/python/qmk/tests/test_qmk_keymap.py b/lib/python/qmk/tests/test_qmk_keymap.py
new file mode 100644
index 0000000000..34360d3b6d
--- /dev/null
+++ b/lib/python/qmk/tests/test_qmk_keymap.py
@@ -0,0 +1,47 @@
+import qmk.keymap
+
+
+def test_generate_c_pytest_basic():
+    keymap_json = {
+        'keyboard': 'handwired/pytest/basic',
+        'layout': 'LAYOUT',
+        'layers': [['KC_A']],
+        'macros': None,
+    }
+    templ = qmk.keymap.generate_c(keymap_json)
+    assert templ == """#include QMK_KEYBOARD_H
+#if __has_include("keymap.h")
+#    include "keymap.h"
+#endif
+
+
+/* THIS FILE WAS GENERATED!
+ *
+ * This file was generated by qmk json2c. You may or may not want to
+ * edit it directly.
+ */
+
+const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
+    [0] = LAYOUT(KC_A)
+};
+
+
+
+
+#ifdef OTHER_KEYMAP_C
+#    include OTHER_KEYMAP_C
+#endif // OTHER_KEYMAP_C
+"""
+
+
+def test_generate_json_pytest_basic():
+    templ = qmk.keymap.generate_json('default', 'handwired/pytest/basic', 'LAYOUT', [['KC_A']])
+    assert templ == {"keyboard": "handwired/pytest/basic", "keymap": "default", "layout": "LAYOUT", "layers": [["KC_A"]]}
+
+
+def test_parse_keymap_c():
+    parsed_keymap_c = qmk.keymap.parse_keymap_c('keyboards/handwired/pytest/basic/keymaps/default/keymap.c')
+    assert parsed_keymap_c == {'layers': [{'name': '0', 'layout': 'LAYOUT_ortho_1x1', 'keycodes': ['KC_A']}]}
+
+
+# FIXME(skullydazed): Add a test for qmk.keymap.write that mocks up an FD.
diff --git a/lib/python/qmk/tests/test_qmk_path.py b/lib/python/qmk/tests/test_qmk_path.py
new file mode 100644
index 0000000000..cc068e39da
--- /dev/null
+++ b/lib/python/qmk/tests/test_qmk_path.py
@@ -0,0 +1,14 @@
+import os
+from pathlib import Path
+
+import qmk.path
+
+
+def test_keymap_pytest_basic():
+    path = qmk.path.keymap('handwired/pytest/basic', 'default')
+    assert path.samefile('keyboards/handwired/pytest/basic/keymaps/default')
+
+
+def test_normpath():
+    path = qmk.path.normpath('lib/python')
+    assert path.samefile(Path(os.environ['ORIG_CWD']) / 'lib/python')
diff --git a/lib/python/qmk/userspace.py b/lib/python/qmk/userspace.py
new file mode 100644
index 0000000000..881490f796
--- /dev/null
+++ b/lib/python/qmk/userspace.py
@@ -0,0 +1,217 @@
+# Copyright 2023-2024 Nick Brassel (@tzarc)
+# SPDX-License-Identifier: GPL-2.0-or-later
+from os import environ
+from pathlib import Path
+import json
+import jsonschema
+
+from milc import cli
+
+from qmk.json_schema import validate, json_load
+from qmk.json_encoders import UserspaceJSONEncoder
+
+
+def qmk_userspace_paths():
+    test_dirs = []
+
+    # If we're already in a directory with a qmk.json and a keyboards or layouts directory, interpret it as userspace
+    if environ.get('ORIG_CWD') is not None:
+        current_dir = Path(environ['ORIG_CWD'])
+        while len(current_dir.parts) > 1:
+            if (current_dir / 'qmk.json').is_file():
+                test_dirs.append(current_dir)
+            current_dir = current_dir.parent
+
+    # If we have a QMK_USERSPACE environment variable, use that
+    if environ.get('QMK_USERSPACE') is not None:
+        current_dir = Path(environ['QMK_USERSPACE']).expanduser()
+        if current_dir.is_dir():
+            test_dirs.append(current_dir)
+
+    # If someone has configured a directory, use that
+    if cli.config.user.overlay_dir is not None:
+        current_dir = Path(cli.config.user.overlay_dir).expanduser().resolve()
+        if current_dir.is_dir():
+            test_dirs.append(current_dir)
+
+    # remove duplicates while maintaining the current order
+    return list(dict.fromkeys(test_dirs))
+
+
+def qmk_userspace_validate(path):
+    # Construct a UserspaceDefs object to ensure it validates correctly
+    if (path / 'qmk.json').is_file():
+        UserspaceDefs(path / 'qmk.json')
+        return
+
+    # No qmk.json file found
+    raise FileNotFoundError('No qmk.json file found.')
+
+
+def detect_qmk_userspace():
+    # Iterate through all the detected userspace paths and return the first one that validates correctly
+    test_dirs = qmk_userspace_paths()
+    for test_dir in test_dirs:
+        try:
+            qmk_userspace_validate(test_dir)
+            return test_dir
+        except FileNotFoundError:
+            continue
+        except UserspaceValidationError:
+            continue
+    return None
+
+
+class UserspaceDefs:
+    def __init__(self, userspace_json: Path):
+        self.path = userspace_json
+        self.build_targets = []
+        json = json_load(userspace_json)
+
+        exception = UserspaceValidationError()
+        success = False
+
+        try:
+            validate(json, 'qmk.user_repo.v0')  # `qmk.json` must have a userspace_version at minimum
+        except jsonschema.ValidationError as err:
+            exception.add('qmk.user_repo.v0', err)
+            raise exception
+
+        # Iterate through each version of the schema, starting with the latest and decreasing to v1
+        schema_versions = [
+            ('qmk.user_repo.v1_1', self.__load_v1_1),  #
+            ('qmk.user_repo.v1', self.__load_v1)  #
+        ]
+
+        for v in schema_versions:
+            schema = v[0]
+            loader = v[1]
+            try:
+                validate(json, schema)
+                loader(json)
+                success = True
+                break
+            except jsonschema.ValidationError as err:
+                exception.add(schema, err)
+
+        if not success:
+            raise exception
+
+    def save(self):
+        target_json = {
+            "userspace_version": "1.1",  # Needs to match latest version
+            "build_targets": []
+        }
+
+        for e in self.build_targets:
+            if isinstance(e, dict):
+                entry = [e['keyboard'], e['keymap']]
+                if 'env' in e:
+                    entry.append(e['env'])
+                target_json['build_targets'].append(entry)
+            elif isinstance(e, Path):
+                target_json['build_targets'].append(str(e.relative_to(self.path.parent)))
+
+        try:
+            # Ensure what we're writing validates against the latest version of the schema
+            validate(target_json, 'qmk.user_repo.v1_1')
+        except jsonschema.ValidationError as err:
+            cli.log.error(f'Could not save userspace file: {err}')
+            return False
+
+        # Only actually write out data if it changed
+        old_data = json.dumps(json.loads(self.path.read_text()), cls=UserspaceJSONEncoder, sort_keys=True)
+        new_data = json.dumps(target_json, cls=UserspaceJSONEncoder, sort_keys=True)
+        if old_data != new_data:
+            self.path.write_text(new_data)
+            cli.log.info(f'Saved userspace file to {self.path}.')
+        return True
+
+    def add_target(self, keyboard=None, keymap=None, build_env=None, json_path=None, do_print=True):
+        if json_path is not None:
+            # Assume we're adding a json filename/path
+            json_path = Path(json_path)
+            if json_path not in self.build_targets:
+                self.build_targets.append(json_path)
+                if do_print:
+                    cli.log.info(f'Added {json_path} to userspace build targets.')
+            else:
+                cli.log.info(f'{json_path} is already a userspace build target.')
+
+        elif keyboard is not None and keymap is not None:
+            # Both keyboard/keymap specified
+            e = {"keyboard": keyboard, "keymap": keymap}
+            if build_env is not None:
+                e['env'] = build_env
+            if e not in self.build_targets:
+                self.build_targets.append(e)
+                if do_print:
+                    cli.log.info(f'Added {keyboard}:{keymap} to userspace build targets.')
+            else:
+                if do_print:
+                    cli.log.info(f'{keyboard}:{keymap} is already a userspace build target.')
+
+    def remove_target(self, keyboard=None, keymap=None, build_env=None, json_path=None, do_print=True):
+        if json_path is not None:
+            # Assume we're removing a json filename/path
+            json_path = Path(json_path)
+            if json_path in self.build_targets:
+                self.build_targets.remove(json_path)
+                if do_print:
+                    cli.log.info(f'Removed {json_path} from userspace build targets.')
+            else:
+                cli.log.info(f'{json_path} is not a userspace build target.')
+
+        elif keyboard is not None and keymap is not None:
+            # Both keyboard/keymap specified
+            e = {"keyboard": keyboard, "keymap": keymap}
+            if build_env is not None:
+                e['env'] = build_env
+            if e in self.build_targets:
+                self.build_targets.remove(e)
+                if do_print:
+                    cli.log.info(f'Removed {keyboard}:{keymap} from userspace build targets.')
+            else:
+                if do_print:
+                    cli.log.info(f'{keyboard}:{keymap} is not a userspace build target.')
+
+    def __load_v1(self, json):
+        for e in json['build_targets']:
+            self.__load_v1_target(e)
+
+    def __load_v1_1(self, json):
+        for e in json['build_targets']:
+            self.__load_v1_1_target(e)
+
+    def __load_v1_target(self, e):
+        if isinstance(e, list) and len(e) == 2:
+            self.add_target(keyboard=e[0], keymap=e[1], do_print=False)
+        if isinstance(e, str):
+            p = self.path.parent / e
+            if p.exists() and p.suffix == '.json':
+                self.add_target(json_path=p, do_print=False)
+
+    def __load_v1_1_target(self, e):
+        # v1.1 adds support for a third item in the build target tuple; kvp's for environment
+        if isinstance(e, list) and len(e) == 3:
+            self.add_target(keyboard=e[0], keymap=e[1], build_env=e[2], do_print=False)
+        else:
+            self.__load_v1_target(e)
+
+
+class UserspaceValidationError(Exception):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__exceptions = []
+
+    def __str__(self):
+        return self.message
+
+    @property
+    def exceptions(self):
+        return self.__exceptions
+
+    def add(self, schema, exception):
+        self.__exceptions.append((schema, exception))
+        errorlist = "\n\n".join([f"{schema}: {exception}" for schema, exception in self.__exceptions])
+        self.message = f'Could not validate against any version of the userspace schema. Errors:\n\n{errorlist}'
diff --git a/lib/python/qmk/util.py b/lib/python/qmk/util.py
new file mode 100644
index 0000000000..6da684a577
--- /dev/null
+++ b/lib/python/qmk/util.py
@@ -0,0 +1,108 @@
+"""Utility functions.
+"""
+import contextlib
+import multiprocessing
+import sys
+import re
+
+from milc import cli
+
+TRIPLET_PATTERN = re.compile(r'^(\d+)\.(\d+)\.(\d+)')
+
+maybe_exit_should_exit = True
+maybe_exit_reraise = False
+
+
+# Controls whether or not early `exit()` calls should be made
+def maybe_exit(rc):
+    if maybe_exit_should_exit:
+        sys.exit(rc)
+    if maybe_exit_reraise:
+        e = sys.exc_info()[1]
+        if e:
+            raise e
+
+
+def maybe_exit_config(should_exit: bool = True, should_reraise: bool = False):
+    global maybe_exit_should_exit
+    global maybe_exit_reraise
+    maybe_exit_should_exit = should_exit
+    maybe_exit_reraise = should_reraise
+
+
+def truthy(value, value_if_unknown=False):
+    """Returns True if the value is truthy, False otherwise.
+
+    Deals with:
+        True: 1, true, t, yes, y, on
+        False: 0, false, f, no, n, off
+    """
+    if value in {False, True}:
+        return bool(value)
+
+    test_value = str(value).strip().lower()
+
+    if test_value in {"1", "true", "t", "yes", "y", "on"}:
+        return True
+
+    if test_value in {"0", "false", "f", "no", "n", "off"}:
+        return False
+
+    return value_if_unknown
+
+
+@contextlib.contextmanager
+def parallelize():
+    """Returns a function that can be used in place of a map() call.
+
+    Attempts to use `mpire`, falling back to `multiprocessing` if it's not
+    available. If parallelization is not requested, returns the original map()
+    function.
+    """
+
+    # Work out if we've already got a config value for parallel searching
+    if cli.config.user.parallel_search is None:
+        parallel_search = True
+    else:
+        parallel_search = cli.config.user.parallel_search
+
+    # Non-parallel searches use `map()`
+    if not parallel_search:
+        yield map
+        return
+
+    # Prefer mpire's `WorkerPool` if it's available
+    with contextlib.suppress(ImportError):
+        from mpire import WorkerPool
+        from mpire.utils import make_single_arguments
+        with WorkerPool() as pool:
+
+            def _worker(func, *args):
+                # Ensure we don't unpack tuples -- mpire's `WorkerPool` tries to do so normally so we tell it not to.
+                for r in pool.imap_unordered(func, make_single_arguments(*args, generator=False), progress_bar=True):
+                    yield r
+
+            yield _worker
+        return
+
+    # Otherwise fall back to multiprocessing's `Pool`
+    with multiprocessing.Pool() as pool:
+        yield pool.imap_unordered
+
+
+def parallel_map(*args, **kwargs):
+    """Effectively runs `map()` but executes it in parallel if necessary.
+    """
+    with parallelize() as map_fn:
+        # This needs to be enclosed in a `list()` as some implementations return
+        # a generator function, which means the scope of the pool is closed off
+        # before the results are returned. Returning a list ensures results are
+        # materialised before any worker pool is shut down.
+        return list(map_fn(*args, **kwargs))
+
+
+def triplet_to_bcd(ver: str):
+    m = TRIPLET_PATTERN.match(ver)
+    if not m:
+        return '0x00000000'
+    return f'0x{int(m.group(1)):02d}{int(m.group(2)):02d}{int(m.group(3)):04d}'