diff --git a/utils/genkeysymdef.js b/utils/genkeysymdef.js
index d21773f9..f539a0b2 100755
--- a/utils/genkeysymdef.js
+++ b/utils/genkeysymdef.js
@@ -9,14 +9,14 @@
 
 const fs = require('fs');
 
-let show_help = process.argv.length === 2;
+let showHelp = process.argv.length === 2;
 let filename;
 
 for (let i = 2; i < process.argv.length; ++i) {
     switch (process.argv[i]) {
         case "--help":
         case "-h":
-            show_help = true;
+            showHelp = true;
             break;
         case "--file":
         case "-f":
@@ -26,11 +26,11 @@ for (let i = 2; i < process.argv.length; ++i) {
 }
 
 if (!filename) {
-    show_help = true;
+    showHelp = true;
     console.log("Error: No filename specified\n");
 }
 
-if (show_help) {
+if (showHelp) {
     console.log("Parses a *nix keysymdef.h to generate Unicode code point mappings");
     console.log("Usage: node parse.js [options] filename:");
     console.log("  -h [ --help ]                 Produce this help message");
diff --git a/utils/use_require.js b/utils/use_require.js
index a410a192..c29f7715 100755
--- a/utils/use_require.js
+++ b/utils/use_require.js
@@ -22,31 +22,31 @@ const paths = {
     core: path.resolve(__dirname, '..', 'core'),
     app: path.resolve(__dirname, '..', 'app'),
     vendor: path.resolve(__dirname, '..', 'vendor'),
-    out_dir_base: path.resolve(__dirname, '..', 'build'),
-    lib_dir_base: path.resolve(__dirname, '..', 'lib'),
+    outDirBase: path.resolve(__dirname, '..', 'build'),
+    libDirBase: path.resolve(__dirname, '..', 'lib'),
 };
 
-const no_copy_files = new Set([
+const noCopyFiles = new Set([
     // skip these -- they don't belong in the processed application
     path.join(paths.vendor, 'sinon.js'),
     path.join(paths.vendor, 'browser-es-module-loader'),
     path.join(paths.app, 'images', 'icons', 'Makefile'),
 ]);
 
-const only_legacy_scripts = new Set([
+const onlyLegacyScripts = new Set([
     path.join(paths.vendor, 'promise.js'),
 ]);
 
-const no_transform_files = new Set([
+const noTransformFiles = new Set([
     // don't transform this -- we want it imported as-is to properly catch loading errors
     path.join(paths.app, 'error-handler.js'),
 ]);
 
-no_copy_files.forEach(file => no_transform_files.add(file));
+noCopyFiles.forEach(file => noTransformFiles.add(file));
 
 // util.promisify requires Node.js 8.x, so we have our own
 function promisify(original) {
-    return function promise_wrap() {
+    return function promiseWrap() {
         const args = Array.prototype.slice.call(arguments);
         return new Promise((resolve, reject) => {
             original.apply(this, args.concat((err, value) => {
@@ -72,10 +72,10 @@ const babelTransformFile = promisify(babel.transformFile);
 
 // walkDir *recursively* walks directories trees,
 // calling the callback for all normal files found.
-function walkDir(base_path, cb, filter) {
-    return readdir(base_path)
+function walkDir(basePath, cb, filter) {
+    return readdir(basePath)
         .then((files) => {
-            const paths = files.map(filename => path.join(base_path, filename));
+            const paths = files.map(filename => path.join(basePath, filename));
             return Promise.all(paths.map(filepath => lstat(filepath)
                 .then((stats) => {
                     if (filter !== undefined && !filter(filepath, stats)) return;
@@ -87,157 +87,157 @@ function walkDir(base_path, cb, filter) {
         });
 }
 
-function transform_html(legacy_scripts, only_legacy) {
+function transformHtml(legacyScripts, onlyLegacy) {
     // write out the modified vnc.html file that works with the bundle
-    const src_html_path = path.resolve(__dirname, '..', 'vnc.html');
-    const out_html_path = path.resolve(paths.out_dir_base, 'vnc.html');
-    return readFile(src_html_path)
-        .then((contents_raw) => {
-            let contents = contents_raw.toString();
+    const srcHtmlPath = path.resolve(__dirname, '..', 'vnc.html');
+    const outHtmlPath = path.resolve(paths.outDirBase, 'vnc.html');
+    return readFile(srcHtmlPath)
+        .then((contentsRaw) => {
+            let contents = contentsRaw.toString();
 
-            const start_marker = '<!-- begin scripts -->\n';
-            const end_marker = '<!-- end scripts -->';
-            const start_ind = contents.indexOf(start_marker) + start_marker.length;
-            const end_ind = contents.indexOf(end_marker, start_ind);
+            const startMarker = '<!-- begin scripts -->\n';
+            const endMarker = '<!-- end scripts -->';
+            const startInd = contents.indexOf(startMarker) + startMarker.length;
+            const endInd = contents.indexOf(endMarker, startInd);
 
-            let new_script = '';
+            let newScript = '';
 
-            if (only_legacy) {
+            if (onlyLegacy) {
             // Only legacy version, so include things directly
-                for (let i = 0;i < legacy_scripts.length;i++) {
-                    new_script += `    <script src="${legacy_scripts[i]}"></script>\n`;
+                for (let i = 0;i < legacyScripts.length;i++) {
+                    newScript += `    <script src="${legacyScripts[i]}"></script>\n`;
                 }
             } else {
                 // Otherwise include both modules and legacy fallbacks
-                new_script += '    <script type="module" crossorigin="anonymous" src="app/ui.js"></script>\n';
-                for (let i = 0;i < legacy_scripts.length;i++) {
-                    new_script += `    <script nomodule src="${legacy_scripts[i]}"></script>\n`;
+                newScript += '    <script type="module" crossorigin="anonymous" src="app/ui.js"></script>\n';
+                for (let i = 0;i < legacyScripts.length;i++) {
+                    newScript += `    <script nomodule src="${legacyScripts[i]}"></script>\n`;
                 }
             }
 
-            contents = contents.slice(0, start_ind) + `${new_script}\n` + contents.slice(end_ind);
+            contents = contents.slice(0, startInd) + `${newScript}\n` + contents.slice(endInd);
 
             return contents;
         })
         .then((contents) => {
-            console.log(`Writing ${out_html_path}`);
-            return writeFile(out_html_path, contents);
+            console.log(`Writing ${outHtmlPath}`);
+            return writeFile(outHtmlPath, contents);
         });
 }
 
-function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
-    if (!import_format) {
+function makeLibFiles(importFormat, sourceMaps, withAppDir, onlyLegacy) {
+    if (!importFormat) {
         throw new Error("you must specify an import format to generate compiled noVNC libraries");
-    } else if (!SUPPORTED_FORMATS.has(import_format)) {
-        throw new Error(`unsupported output format "${import_format}" for import/export -- only ${Array.from(SUPPORTED_FORMATS)} are supported`);
+    } else if (!SUPPORTED_FORMATS.has(importFormat)) {
+        throw new Error(`unsupported output format "${importFormat}" for import/export -- only ${Array.from(SUPPORTED_FORMATS)} are supported`);
     }
 
-    // NB: we need to make a copy of babel_opts, since babel sets some defaults on it
-    const babel_opts = () => ({
+    // NB: we need to make a copy of babelOpts, since babel sets some defaults on it
+    const babelOpts = () => ({
         plugins: [],
         presets: [
             [ '@babel/preset-env',
               { targets: 'ie >= 11',
-                modules: import_format } ]
+                modules: importFormat } ]
         ],
         ast: false,
-        sourceMaps: source_maps,
+        sourceMaps: sourceMaps,
     });
 
     // No point in duplicate files without the app, so force only converted files
-    if (!with_app_dir) {
-        only_legacy = true;
+    if (!withAppDir) {
+        onlyLegacy = true;
     }
 
-    let in_path;
-    let out_path_base;
-    if (with_app_dir) {
-        out_path_base = paths.out_dir_base;
-        in_path = paths.main;
+    let inPath;
+    let outPathBase;
+    if (withAppDir) {
+        outPathBase = paths.outDirBase;
+        inPath = paths.main;
     } else {
-        out_path_base = paths.lib_dir_base;
+        outPathBase = paths.libDirBase;
     }
-    const legacy_path_base = only_legacy ? out_path_base : path.join(out_path_base, 'legacy');
+    const legacyPathBase = onlyLegacy ? outPathBase : path.join(outPathBase, 'legacy');
 
-    fse.ensureDirSync(out_path_base);
+    fse.ensureDirSync(outPathBase);
 
     const helpers = require('./use_require_helpers');
-    const helper = helpers[import_format];
+    const helper = helpers[importFormat];
 
     const outFiles = [];
     const legacyFiles = [];
 
-    const handleDir = (js_only, vendor_rewrite, in_path_base, filename) => Promise.resolve()
+    const handleDir = (jsOnly, vendorRewrite, inPathBase, filename) => Promise.resolve()
         .then(() => {
-            const out_path = path.join(out_path_base, path.relative(in_path_base, filename));
-            const legacy_path = path.join(legacy_path_base, path.relative(in_path_base, filename));
+            const outPath = path.join(outPathBase, path.relative(inPathBase, filename));
+            const legacyPath = path.join(legacyPathBase, path.relative(inPathBase, filename));
 
             if (path.extname(filename) !== '.js') {
-                if (!js_only) {
-                    console.log(`Writing ${out_path}`);
-                    return copy(filename, out_path);
+                if (!jsOnly) {
+                    console.log(`Writing ${outPath}`);
+                    return copy(filename, outPath);
                 }
                 return;  // skip non-javascript files
             }
 
-            if (no_transform_files.has(filename)) {
-                return ensureDir(path.dirname(out_path))
+            if (noTransformFiles.has(filename)) {
+                return ensureDir(path.dirname(outPath))
                     .then(() => {
-                        console.log(`Writing ${out_path}`);
-                        return copy(filename, out_path);
+                        console.log(`Writing ${outPath}`);
+                        return copy(filename, outPath);
                     });
             }
 
-            if (only_legacy_scripts.has(filename)) {
-                legacyFiles.push(legacy_path);
-                return ensureDir(path.dirname(legacy_path))
+            if (onlyLegacyScripts.has(filename)) {
+                legacyFiles.push(legacyPath);
+                return ensureDir(path.dirname(legacyPath))
                     .then(() => {
-                        console.log(`Writing ${legacy_path}`);
-                        return copy(filename, legacy_path);
+                        console.log(`Writing ${legacyPath}`);
+                        return copy(filename, legacyPath);
                     });
             }
 
             return Promise.resolve()
                 .then(() => {
-                    if (only_legacy) {
+                    if (onlyLegacy) {
                         return;
                     }
-                    return ensureDir(path.dirname(out_path))
+                    return ensureDir(path.dirname(outPath))
                         .then(() => {
-                            console.log(`Writing ${out_path}`);
-                            return copy(filename, out_path);
+                            console.log(`Writing ${outPath}`);
+                            return copy(filename, outPath);
                         });
                 })
-                .then(() => ensureDir(path.dirname(legacy_path)))
+                .then(() => ensureDir(path.dirname(legacyPath)))
                 .then(() => {
-                    const opts = babel_opts();
+                    const opts = babelOpts();
                     if (helper && helpers.optionsOverride) {
                         helper.optionsOverride(opts);
                     }
             // Adjust for the fact that we move the core files relative
             // to the vendor directory
-                    if (vendor_rewrite) {
+                    if (vendorRewrite) {
                         opts.plugins.push(["import-redirect",
-                                           {"root": legacy_path_base,
+                                           {"root": legacyPathBase,
                                             "redirect": { "vendor/(.+)": "./vendor/$1"}}]);
                     }
 
                     return babelTransformFile(filename, opts)
                         .then((res) => {
-                            console.log(`Writing ${legacy_path}`);
+                            console.log(`Writing ${legacyPath}`);
                             const {map} = res;
                             let {code} = res;
-                            if (source_maps === true) {
+                            if (sourceMaps === true) {
                     // append URL for external source map
-                                code += `\n//# sourceMappingURL=${path.basename(legacy_path)}.map\n`;
+                                code += `\n//# sourceMappingURL=${path.basename(legacyPath)}.map\n`;
                             }
-                            outFiles.push(`${legacy_path}`);
-                            return writeFile(legacy_path, code)
+                            outFiles.push(`${legacyPath}`);
+                            return writeFile(legacyPath, code)
                                 .then(() => {
-                                    if (source_maps === true || source_maps === 'both') {
-                                        console.log(`  and ${legacy_path}.map`);
-                                        outFiles.push(`${legacy_path}.map`);
-                                        return writeFile(`${legacy_path}.map`, JSON.stringify(map));
+                                    if (sourceMaps === true || sourceMaps === 'both') {
+                                        console.log(`  and ${legacyPath}.map`);
+                                        outFiles.push(`${legacyPath}.map`);
+                                        return writeFile(`${legacyPath}.map`, JSON.stringify(map));
                                     }
                                 });
                         });
@@ -246,45 +246,45 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
 
     Promise.resolve()
         .then(() => {
-            const handler = handleDir.bind(null, true, false, in_path || paths.main);
-            const filter = (filename, stats) => !no_copy_files.has(filename);
+            const handler = handleDir.bind(null, true, false, inPath || paths.main);
+            const filter = (filename, stats) => !noCopyFiles.has(filename);
             return walkDir(paths.vendor, handler, filter);
         })
         .then(() => {
-            const handler = handleDir.bind(null, true, !in_path, in_path || paths.core);
-            const filter = (filename, stats) => !no_copy_files.has(filename);
+            const handler = handleDir.bind(null, true, !inPath, inPath || paths.core);
+            const filter = (filename, stats) => !noCopyFiles.has(filename);
             return walkDir(paths.core, handler, filter);
         })
         .then(() => {
-            if (!with_app_dir) return;
-            const handler = handleDir.bind(null, false, false, in_path);
-            const filter = (filename, stats) => !no_copy_files.has(filename);
+            if (!withAppDir) return;
+            const handler = handleDir.bind(null, false, false, inPath);
+            const filter = (filename, stats) => !noCopyFiles.has(filename);
             return walkDir(paths.app, handler, filter);
         })
         .then(() => {
-            if (!with_app_dir) return;
+            if (!withAppDir) return;
 
             if (!helper || !helper.appWriter) {
-                throw new Error(`Unable to generate app for the ${import_format} format!`);
+                throw new Error(`Unable to generate app for the ${importFormat} format!`);
             }
 
-            const out_app_path = path.join(legacy_path_base, 'app.js');
-            console.log(`Writing ${out_app_path}`);
-            return helper.appWriter(out_path_base, legacy_path_base, out_app_path)
-                .then((extra_scripts) => {
-                    let legacy_scripts = [];
+            const outAppPath = path.join(legacyPathBase, 'app.js');
+            console.log(`Writing ${outAppPath}`);
+            return helper.appWriter(outPathBase, legacyPathBase, outAppPath)
+                .then((extraScripts) => {
+                    let legacyScripts = [];
 
                     legacyFiles.forEach((file) => {
-                        let rel_file_path = path.relative(out_path_base, file);
-                        legacy_scripts.push(rel_file_path);
+                        let relFilePath = path.relative(outPathBase, file);
+                        legacyScripts.push(relFilePath);
                     });
 
-                    legacy_scripts = legacy_scripts.concat(extra_scripts);
+                    legacyScripts = legacyScripts.concat(extraScripts);
 
-                    let rel_app_path = path.relative(out_path_base, out_app_path);
-                    legacy_scripts.push(rel_app_path);
+                    let relAppPath = path.relative(outPathBase, outAppPath);
+                    legacyScripts.push(relAppPath);
 
-                    transform_html(legacy_scripts, only_legacy);
+                    transformHtml(legacyScripts, onlyLegacy);
                 })
                 .then(() => {
                     if (!helper.removeModules) return;
@@ -292,15 +292,15 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
                     return Promise.all(outFiles.map((filepath) => {
                         unlink(filepath)
                             .then(() => {
-                    // Try to clean up any empty directories if this
-                    // was the last file in there
-                                const rmdir_r = dir =>
+                                // Try to clean up any empty directories if
+                                // this was the last file in there
+                                const rmdirR = dir =>
                                     rmdir(dir)
-                                        .then(() => rmdir_r(path.dirname(dir)))
+                                        .then(() => rmdirR(path.dirname(dir)))
                                         .catch(() => {
-                            // Assume the error was ENOTEMPTY and ignore it
+                                // Assume the error was ENOTEMPTY and ignore it
                                         });
-                                return rmdir_r(path.dirname(filepath));
+                                return rmdirR(path.dirname(filepath));
                             });
                     }));
                 });
@@ -312,11 +312,11 @@ function make_lib_files(import_format, source_maps, with_app_dir, only_legacy) {
 }
 
 if (program.clean) {
-    console.log(`Removing ${paths.lib_dir_base}`);
-    fse.removeSync(paths.lib_dir_base);
+    console.log(`Removing ${paths.libDirBase}`);
+    fse.removeSync(paths.libDirBase);
 
-    console.log(`Removing ${paths.out_dir_base}`);
-    fse.removeSync(paths.out_dir_base);
+    console.log(`Removing ${paths.outDirBase}`);
+    fse.removeSync(paths.outDirBase);
 }
 
-make_lib_files(program.as, program.withSourceMaps, program.withApp, program.onlyLegacy);
+makeLibFiles(program.as, program.withSourceMaps, program.withApp, program.onlyLegacy);
diff --git a/utils/use_require_helpers.js b/utils/use_require_helpers.js
index 0a930ee6..8ad45726 100644
--- a/utils/use_require_helpers.js
+++ b/utils/use_require_helpers.js
@@ -4,7 +4,7 @@ const path = require('path');
 
 // util.promisify requires Node.js 8.x, so we have our own
 function promisify(original) {
-    return function promise_wrap() {
+    return function promiseWrap() {
         const args = Array.prototype.slice.call(arguments);
         return new Promise((resolve, reject) => {
             original.apply(this, args.concat((err, value) => {
@@ -19,39 +19,39 @@ const writeFile = promisify(fs.writeFile);
 
 module.exports = {
     'amd': {
-        appWriter: (base_out_path, script_base_path, out_path) => {
+        appWriter: (baseOutPath, scriptBasePath, outPath) => {
             // setup for requirejs
-            const ui_path = path.relative(base_out_path,
-                                          path.join(script_base_path, 'app', 'ui'));
-            return writeFile(out_path, `requirejs(["${ui_path}"], function (ui) {});`)
+            const uiPath = path.relative(baseOutPath,
+                                         path.join(scriptBasePath, 'app', 'ui'));
+            return writeFile(outPath, `requirejs(["${uiPath}"], function (ui) {});`)
                 .then(() => {
-                    console.log(`Please place RequireJS in ${path.join(script_base_path, 'require.js')}`);
-                    const require_path = path.relative(base_out_path,
-                                                       path.join(script_base_path, 'require.js'));
-                    return [ require_path ];
+                    console.log(`Please place RequireJS in ${path.join(scriptBasePath, 'require.js')}`);
+                    const requirePath = path.relative(baseOutPath,
+                                                      path.join(scriptBasePath, 'require.js'));
+                    return [ requirePath ];
                 });
         },
     },
     'commonjs': {
-        appWriter: (base_out_path, script_base_path, out_path) => {
+        appWriter: (baseOutPath, scriptBasePath, outPath) => {
             const browserify = require('browserify');
-            const b = browserify(path.join(script_base_path, 'app/ui.js'), {});
+            const b = browserify(path.join(scriptBasePath, 'app/ui.js'), {});
             return promisify(b.bundle).call(b)
-                .then(buf => writeFile(out_path, buf))
+                .then(buf => writeFile(outPath, buf))
                 .then(() => []);
         },
         removeModules: true,
     },
     'systemjs': {
-        appWriter: (base_out_path, script_base_path, out_path) => {
-            const ui_path = path.relative(base_out_path,
-                                          path.join(script_base_path, 'app', 'ui.js'));
-            return writeFile(out_path, `SystemJS.import("${ui_path}");`)
+        appWriter: (baseOutPath, scriptBasePath, outPath) => {
+            const uiPath = path.relative(baseOutPath,
+                                         path.join(scriptBasePath, 'app', 'ui.js'));
+            return writeFile(outPath, `SystemJS.import("${uiPath}");`)
                 .then(() => {
-                    console.log(`Please place SystemJS in ${path.join(script_base_path, 'system-production.js')}`);
-                    const systemjs_path = path.relative(base_out_path,
-                                                        path.join(script_base_path, 'system-production.js'));
-                    return [ systemjs_path ];
+                    console.log(`Please place SystemJS in ${path.join(scriptBasePath, 'system-production.js')}`);
+                    const systemjsPath = path.relative(baseOutPath,
+                                                       path.join(scriptBasePath, 'system-production.js'));
+                    return [ systemjsPath ];
                 });
         },
     },