diff --git a/Src/executables/IronPython.Compiler/IconInjector.cs b/Src/executables/IronPython.Compiler/IconInjector.cs
new file mode 100644
index 000000000..8c7f2e5dc
--- /dev/null
+++ b/Src/executables/IronPython.Compiler/IconInjector.cs
@@ -0,0 +1,202 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace IronPython.Compiler {
+
+    /// <remarks>
+    /// Fork from <see href="https://github.com/INotGreen/SharpThief/blob/main/IconInjector.cs"/>.
+    /// </remarks>
+    internal static class IconInjector {
+
+        private const nint RT_ICON = 3;
+        private const nint RT_GROUP_ICON = 14;
+
+        public static void InjectIcon(string exeFileName, string iconFileName, nint iconGroupID = 1, ushort iconBaseID = 1) {
+            IconFile iconFile = IconFile.FromFile(iconFileName);
+            nint hUpdate = BeginUpdateResourceW(exeFileName, false);
+            byte[] data = iconFile.CreateIconGroupData(iconBaseID);
+            UpdateResourceW(hUpdate, RT_GROUP_ICON, iconGroupID, 0, data, data.Length);
+            for (int i = 0; i <= iconFile.ImageCount - 1; i++) {
+                byte[] image = iconFile[i];
+                UpdateResourceW(hUpdate, RT_ICON, iconBaseID + i, 0, image, image.Length);
+            }
+            EndUpdateResourceW(hUpdate, false);
+        }
+
+        [DllImport("kernel32", CharSet = CharSet.Unicode)]
+        private static extern nint BeginUpdateResourceW([In] string fileName, [In][MarshalAs(UnmanagedType.Bool)] bool deleteExistingResources);
+
+        [DllImport("kernel32")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool UpdateResourceW([In] nint hUpdate, [In] nint type, [In] nint name, [In] short language, [In, Optional][MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 5)] byte[] data, [In] int dataSize);
+
+        [DllImport("kernel32")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool EndUpdateResourceW([In] nint hUpdate, [In][MarshalAs(UnmanagedType.Bool)] bool discard);
+
+        // The first structure in an ICO file lets us know how many images are in the file.
+        [StructLayout(LayoutKind.Sequential)]
+        private struct ICONDIR {
+            // Reserved, must be 0
+            public ushort Reserved;
+            // Resource type, 1 for icons.
+            public ushort Type;
+            // How many images.
+            public ushort Count;
+            // The native structure has an array of ICONDIRENTRYs as a final field.
+        }
+
+        // Each ICONDIRENTRY describes one icon stored in the ico file. The offset says where the icon image data
+        // starts in the file. The other fields give the information required to turn that image data into a valid
+        // bitmap.
+        [StructLayout(LayoutKind.Sequential)]
+        private struct ICONDIRENTRY {
+            /// <summary>
+            /// The width, in pixels, of the image.
+            /// </summary>
+            public byte Width;
+            /// <summary>
+            /// The height, in pixels, of the image.
+            /// </summary>
+            public byte Height;
+            /// <summary>
+            /// The number of colors in the image; (0 if >= 8bpp)
+            /// </summary>
+            public byte ColorCount;
+            /// <summary>
+            /// Reserved (must be 0).
+            /// </summary>
+            public byte Reserved;
+            /// <summary>
+            /// Color planes.
+            /// </summary>
+            public ushort Planes;
+            /// <summary>
+            /// Bits per pixel.
+            /// </summary>
+            public ushort BitCount;
+            /// <summary>
+            /// The length, in bytes, of the pixel data.
+            /// </summary>
+            public int BytesInRes;
+            /// <summary>
+            /// The offset in the file where the pixel data starts.
+            /// </summary>
+            public int ImageOffset;
+        }
+
+        // Each image is stored in the file as an ICONIMAGE structure:
+        //typdef struct
+        //{
+        //   BITMAPINFOHEADER   icHeader;      // DIB header
+        //   RGBQUAD         icColors[1];   // Color table
+        //   BYTE            icXOR[1];      // DIB bits for XOR mask
+        //   BYTE            icAND[1];      // DIB bits for AND mask
+        //} ICONIMAGE, *LPICONIMAGE;
+
+
+        [StructLayout(LayoutKind.Sequential)]
+        private struct BITMAPINFOHEADER {
+            public uint Size;
+            public int Width;
+            public int Height;
+            public ushort Planes;
+            public ushort BitCount;
+            public uint Compression;
+            public uint SizeImage;
+            public int XPelsPerMeter;
+            public int YPelsPerMeter;
+            public uint ClrUsed;
+            public uint ClrImportant;
+        }
+
+        // The icon in an exe/dll file is stored in a very similar structure:
+        [StructLayout(LayoutKind.Sequential, Pack = 2)]
+        private struct GRPICONDIRENTRY {
+            public byte Width;
+            public byte Height;
+            public byte ColorCount;
+            public byte Reserved;
+            public ushort Planes;
+            public ushort BitCount;
+            public int BytesInRes;
+            public ushort ID;
+        }
+
+        private class IconFile {
+            private ICONDIR iconDir;
+            private ICONDIRENTRY[] iconEntry;
+
+            private byte[][] iconImage;
+
+            public ushort ImageCount => iconDir.Count;
+
+            public byte[] this[int index] => iconImage[index];
+
+            public static unsafe IconFile FromFile(string filename) {
+                IconFile instance = new IconFile();
+                // Read all the bytes from the file.
+                byte[] fileBytes = System.IO.File.ReadAllBytes(filename);
+                // First struct is an ICONDIR
+                // Pin the bytes from the file in memory so that we can read them.
+                // If we didn't pin them then they could move around (e.g. when the
+                // garbage collector compacts the heap)
+                fixed (byte* pinnedBytes = fileBytes) {
+                    ICONDIR* iconDirs = (ICONDIR*)pinnedBytes;
+                    // Read the ICONDIR
+                    instance.iconDir = iconDirs[0];
+                    // which tells us how many images are in the ico file. For each image, there's a ICONDIRENTRY, and associated pixel data.
+                    instance.iconEntry = new ICONDIRENTRY[instance.iconDir.Count];
+                    instance.iconImage = new byte[instance.iconDir.Count][];
+                    // The first ICONDIRENTRY will be immediately after the ICONDIR, so the offset to it is the size of ICONDIR
+                    ICONDIRENTRY* array = (ICONDIRENTRY*)(iconDirs + 1);
+                    // After reading an ICONDIRENTRY we step forward by the size of an ICONDIRENTRY
+                    for (int i = 0; i < instance.iconDir.Count; i++) {
+                        // Grab the structure.
+                        ICONDIRENTRY entry = array[i];
+                        instance.iconEntry[i] = entry;
+                        // Grab the associated pixel data.
+                        byte[] image = new byte[entry.BytesInRes];
+                        Buffer.BlockCopy(fileBytes, entry.ImageOffset, image, 0, entry.BytesInRes);
+                        instance.iconImage[i] = image;
+                    }
+                }
+                return instance;
+            }
+
+            public unsafe byte[] CreateIconGroupData(ushort iconBaseID) {
+                // This will store the memory version of the icon.
+                int sizeOfIconGroupData = sizeof(ICONDIR) +
+                                          sizeof(GRPICONDIRENTRY) * ImageCount;
+                byte[] data = new byte[sizeOfIconGroupData];
+                fixed (byte* pinnedData = data) {
+                    ICONDIR* iconDirs = (ICONDIR*)pinnedData;
+                    iconDirs[0] = iconDir;
+                    GRPICONDIRENTRY* array = (GRPICONDIRENTRY*)(iconDirs + 1);
+                    for (ushort i = 0; i < ImageCount; i++) {
+                        byte[] image = iconImage[i];
+                        fixed (byte* pinnedBitmapInfoHeader = image) {
+                            BITMAPINFOHEADER bitmapHeader = *(BITMAPINFOHEADER*)pinnedBitmapInfoHeader;
+                            GRPICONDIRENTRY grpEntry = new GRPICONDIRENTRY {
+                                Width = iconEntry[i].Width,
+                                Height = iconEntry[i].Height,
+                                ColorCount = iconEntry[i].ColorCount,
+                                Reserved = iconEntry[i].Reserved,
+                                Planes = bitmapHeader.Planes,
+                                BitCount = bitmapHeader.BitCount,
+                                BytesInRes = iconEntry[i].BytesInRes,
+                                ID = checked((ushort)(iconBaseID + i))
+                            };
+                            array[i] = grpEntry;
+                        }
+                    }
+                }
+                return data;
+            }
+        }
+    }
+}
diff --git a/src/core/IronPython/Runtime/ClrModule.cs b/src/core/IronPython/Runtime/ClrModule.cs
index ea4605735..c872b6477 100644
--- a/src/core/IronPython/Runtime/ClrModule.cs
+++ b/src/core/IronPython/Runtime/ClrModule.cs
@@ -15,6 +15,10 @@
 using ComTypeLibDesc = Microsoft.Scripting.ComInterop.ComTypeLibDesc;
 #endif
 
+#if FEATURE_FILESYSTEM && FEATURE_REFEMIT
+using System.Reflection.Emit;
+#endif
+
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -942,6 +946,196 @@ public static void CompileModules(CodeContext/*!*/ context, string/*!*/ assembly
 
             SavableScriptCode.SaveToAssembly(assemblyName, kwArgs, code.ToArray());
         }
+
+        public static AssemblyGen CreateAssemblyGen(CodeContext/*!*/ context, string/*!*/ assemblyName, [ParamDictionary]IDictionary<string, object> kwArgs, [NotNone] params string/*!*/[]/*!*/ filenames) {
+            ContractUtils.RequiresNotNull(assemblyName, nameof(assemblyName));
+            ContractUtils.RequiresNotNullItems(filenames, nameof(filenames));
+
+            PythonContext pc = context.LanguageContext;
+
+            for (int i = 0; i < filenames.Length; i++) {
+                filenames[i] = Path.GetFullPath(filenames[i]);
+            }
+
+            Dictionary<string, string> packageMap = BuildPackageMap(filenames);
+
+            List<SavableScriptCode> code = new List<SavableScriptCode>();
+            foreach (string filename in filenames) {
+                if (!pc.DomainManager.Platform.FileExists(filename)) {
+                    throw PythonOps.IOError($"Couldn't find file for compilation: {filename}");
+                }
+
+                ScriptCode sc;
+
+                string modName;
+                string dname = Path.GetDirectoryName(filename);
+                string outFilename = "";
+                if (Path.GetFileName(filename) == "__init__.py") {
+                    // remove __init__.py to get package name
+                    dname = Path.GetDirectoryName(dname);
+                    if (String.IsNullOrEmpty(dname)) {
+                        modName = Path.GetDirectoryName(filename);
+                    } else {
+                        modName = Path.GetFileNameWithoutExtension(Path.GetDirectoryName(filename));
+                    }
+                    outFilename = Path.DirectorySeparatorChar + "__init__.py";
+                } else {
+                    modName = Path.GetFileNameWithoutExtension(filename);
+                }
+
+                // see if we have a parent package, if so incorporate it into
+                // our name
+                if (packageMap.TryGetValue(dname, out string parentPackage)) {
+                    modName = parentPackage + "." + modName;
+                }
+
+                outFilename = modName.Replace('.', Path.DirectorySeparatorChar) + outFilename;
+
+                SourceUnit su = pc.CreateSourceUnit(
+                    new FileStreamContentProvider(
+                        context.LanguageContext.DomainManager.Platform,
+                        filename
+                    ),
+                    outFilename,
+                    pc.DefaultEncoding,
+                    SourceCodeKind.File
+                );
+
+                sc = context.LanguageContext.GetScriptCode(su, modName, ModuleOptions.Initialize, Compiler.CompilationMode.ToDisk);
+
+                code.Add((SavableScriptCode)sc);
+            }
+
+            if (kwArgs != null && kwArgs.TryGetValue("mainModule", out object mainModule)) {
+                if (mainModule is string strModule) {
+                    if (!pc.DomainManager.Platform.FileExists(strModule)) {
+                        throw PythonOps.IOError("Couldn't find main file for compilation: {0}", strModule);
+                    }
+
+                    SourceUnit su = pc.CreateFileUnit(strModule, pc.DefaultEncoding, SourceCodeKind.File);
+                    code.Add((SavableScriptCode)context.LanguageContext.GetScriptCode(su, "__main__", ModuleOptions.Initialize, Compiler.CompilationMode.ToDisk));
+                }
+            }
+
+            return CreateAssemblyGen(assemblyName, kwArgs, code.ToArray());
+        }
+
+        private class CodeInfo {
+            public readonly MethodBuilder Builder;
+            public readonly ScriptCode Code;
+            public readonly Type DelegateType;
+
+            public CodeInfo(MethodBuilder builder, ScriptCode code, Type delegateType) {
+                Builder = builder;
+                Code = code;
+                DelegateType = delegateType;
+            }
+        }
+
+        private static AssemblyGen CreateAssemblyGen(string assemblyName, IDictionary<string, object> assemblyAttributes, params SavableScriptCode[] codes) {
+            ContractUtils.RequiresNotNull(assemblyName, nameof(assemblyName));
+            ContractUtils.RequiresNotNullItems(codes, nameof(codes));
+
+            // break the assemblyName into it's dir/name/extension
+            string dir = Path.GetDirectoryName(assemblyName);
+            if (string.IsNullOrEmpty(dir)) {
+                dir = Environment.CurrentDirectory;
+            }
+
+            string name = Path.GetFileNameWithoutExtension(assemblyName);
+            string ext = Path.GetExtension(assemblyName);
+
+            // build the assembly & type gen that all the script codes will live in...
+            AssemblyGen ag = new AssemblyGen(new AssemblyName(name), dir, ext, /*emitSymbols*/false, assemblyAttributes);
+            TypeBuilder tb = ag.DefinePublicType("DLRCachedCode", typeof(object), true);
+            TypeGen tg = new TypeGen(ag, tb);
+            // then compile all of the code
+
+            MethodInfo compileForSave =
+                typeof(SavableScriptCode).GetMethod(
+                    "CompileForSave",
+                    BindingFlags.Instance | BindingFlags.NonPublic,
+                    Type.DefaultBinder,
+                    new[] { typeof(TypeGen) },
+                    null);
+
+            Dictionary<Type, List<CodeInfo>> langCtxBuilders = new Dictionary<Type, List<CodeInfo>>();
+            foreach (SavableScriptCode sc in codes) {
+                if (!langCtxBuilders.TryGetValue(sc.LanguageContext.GetType(), out List<CodeInfo> builders)) {
+                    langCtxBuilders[sc.LanguageContext.GetType()] = builders = new List<CodeInfo>();
+                }
+                KeyValuePair<MethodBuilder, Type> compInfo = (KeyValuePair<MethodBuilder, Type>)compileForSave.Invoke(sc, new[] { tg });
+
+                builders.Add(new CodeInfo(compInfo.Key, sc, compInfo.Value));
+            }
+
+            MethodBuilder mb = tb.DefineMethod(
+                "GetScriptCodeInfo",
+                MethodAttributes.SpecialName | MethodAttributes.Public | MethodAttributes.Static,
+                typeof(MutableTuple<Type[], Delegate[][], string[][], string[][]>),
+                ReflectionUtils.EmptyTypes);
+
+            ILGen ilgen = new ILGen(mb.GetILGenerator());
+
+            var langsWithBuilders = langCtxBuilders.ToArray();
+
+            // lang ctx array
+            ilgen.EmitArray(typeof(Type), langsWithBuilders.Length, (index) => {
+                ilgen.Emit(OpCodes.Ldtoken, langsWithBuilders[index].Key);
+                ilgen.EmitCall(typeof(Type).GetMethod(nameof(Type.GetTypeFromHandle), new[] { typeof(RuntimeTypeHandle) }));
+            });
+
+            // builders array of array
+            ilgen.EmitArray(typeof(Delegate[]), langsWithBuilders.Length, (index) => {
+                List<CodeInfo> builders = langsWithBuilders[index].Value;
+
+                ilgen.EmitArray(typeof(Delegate), builders.Count, (innerIndex) => {
+                    ilgen.EmitNull();
+                    ilgen.Emit(OpCodes.Ldftn, builders[innerIndex].Builder);
+                    ilgen.EmitNew(
+                        builders[innerIndex].DelegateType,
+                        new[] { typeof(object), typeof(IntPtr) }
+                    );
+                });
+            });
+
+            // paths array of array
+            ilgen.EmitArray(typeof(string[]), langsWithBuilders.Length, (index) => {
+                List<CodeInfo> builders = langsWithBuilders[index].Value;
+
+                ilgen.EmitArray(typeof(string), builders.Count, (innerIndex) => {
+                    ilgen.EmitString(builders[innerIndex].Code.SourceUnit.Path);
+                });
+            });
+
+            // 4th element in tuple - custom per-language data
+            ilgen.EmitArray(typeof(string[]), langsWithBuilders.Length, (index) => {
+                List<CodeInfo> builders = langsWithBuilders[index].Value;
+
+                ilgen.EmitArray(typeof(string), builders.Count, (innerIndex) => {
+                    ICustomScriptCodeData data = builders[innerIndex].Code as ICustomScriptCodeData;
+                    if (data != null) {
+                        ilgen.EmitString(data.GetCustomScriptCodeData());
+                    } else {
+                        ilgen.Emit(OpCodes.Ldnull);
+                    }
+                });
+            });
+
+            ilgen.EmitNew(
+                typeof(MutableTuple<Type[], Delegate[][], string[][], string[][]>),
+                new[] { typeof(Type[]), typeof(Delegate[][]), typeof(string[][]), typeof(string[][]) }
+            );
+            ilgen.Emit(OpCodes.Ret);
+
+            mb.SetCustomAttribute(new CustomAttributeBuilder(
+                typeof(DlrCachedCodeAttribute).GetConstructor(ReflectionUtils.EmptyTypes),
+                ArrayUtils.EmptyObjects
+            ));
+
+            tg.FinishType();
+            return ag;
+        }
 #endif
 
 #if FEATURE_REFEMIT
diff --git a/src/executables/IronPython.Compiler/Config.cs b/src/executables/IronPython.Compiler/Config.cs
index 59600f799..2b7605c4d 100644
--- a/src/executables/IronPython.Compiler/Config.cs
+++ b/src/executables/IronPython.Compiler/Config.cs
@@ -1,14 +1,15 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
 using System.Text;
 
-using IKVM.Reflection.Emit;
-
 using Microsoft.Scripting.Runtime;
 
 namespace IronPython.Compiler {
@@ -17,8 +18,8 @@ public class Config {
         public Config() {
             Embed = false;
             Files = new List<string>();
-            Platform = IKVM.Reflection.PortableExecutableKinds.ILOnly;
-            Machine = IKVM.Reflection.ImageFileMachine.AMD64;
+            Platform = PortableExecutableKinds.ILOnly;
+            Machine = ImageFileMachine.I386;
             Standalone = false;
             Target = PEFileKinds.Dll;
             UseMta = false;
@@ -106,6 +107,11 @@ public bool Standalone {
             private set;
         }
 
+        public bool NoLogo {
+            get;
+            private set;
+        }
+
         public List<string> Files {
             get;
             private set;
@@ -126,12 +132,12 @@ public bool Embed {
             internal set;
         }
 
-        public IKVM.Reflection.ImageFileMachine Machine {
+        public ImageFileMachine Machine {
             get;
             private set;
         }
 
-        public IKVM.Reflection.PortableExecutableKinds Platform {
+        public PortableExecutableKinds Platform {
             get;
             private set;
         }
@@ -154,7 +160,7 @@ public void ParseArgs(IEnumerable<string> args, List<string> respFiles = null) {
                 } else if (arg.StartsWith("/out:", StringComparison.Ordinal)) {
                     Output = arg.Substring(5).Trim('"');
                 } else if (arg.StartsWith("/target:", StringComparison.Ordinal)) {
-                    string tgt = arg.Substring(8).Trim('"');
+                    string tgt = arg.Substring(8).Trim('"').ToLowerInvariant();
                     switch (tgt) {
                         case "exe":
                             Target = PEFileKinds.ConsoleApplication;
@@ -162,24 +168,51 @@ public void ParseArgs(IEnumerable<string> args, List<string> respFiles = null) {
                         case "winexe":
                             Target = PEFileKinds.WindowApplication;
                             break;
+                        case "library":
+                        case "dll":
                         default:
                             Target = PEFileKinds.Dll;
                             break;
                     }
                 } else if (arg.StartsWith("/platform:", StringComparison.Ordinal)) {
-                    string plat = arg.Substring(10).Trim('"');
+                    string plat = arg.Substring(10).Trim('"').ToLowerInvariant();
                     switch (plat) {
                         case "x86":
-                            Platform = IKVM.Reflection.PortableExecutableKinds.ILOnly | IKVM.Reflection.PortableExecutableKinds.Required32Bit;
-                            Machine = IKVM.Reflection.ImageFileMachine.I386;
+                        case "i386":
+                            Platform = PortableExecutableKinds.ILOnly | PortableExecutableKinds.Required32Bit;
+                            Machine = ImageFileMachine.I386;
                             break;
                         case "x64":
-                            Platform = IKVM.Reflection.PortableExecutableKinds.ILOnly | IKVM.Reflection.PortableExecutableKinds.PE32Plus;
-                            Machine = IKVM.Reflection.ImageFileMachine.AMD64;
+                        case "amd64":
+                            Platform = PortableExecutableKinds.ILOnly | PortableExecutableKinds.PE32Plus;
+                            Machine = ImageFileMachine.AMD64;
+                            break;
+                        case "ia64":
+                        case "itanium":
+                            Platform = PortableExecutableKinds.ILOnly;
+                            Machine = ImageFileMachine.IA64;
+                            break;
+                        case "arm":
+                        case "arm32":
+                            Platform = PortableExecutableKinds.ILOnly;
+                            Machine = ImageFileMachine.ARM;
+                            break;
+                        case "arm64":
+                            Platform = PortableExecutableKinds.ILOnly;
+                            Machine = (ImageFileMachine)0xAA64;
+                            break;
+                        case "anycpu":
+                            Platform = PortableExecutableKinds.ILOnly;
+                            Machine = ImageFileMachine.I386;
                             break;
                         default:
-                            Platform = IKVM.Reflection.PortableExecutableKinds.ILOnly;
-                            Machine = IKVM.Reflection.ImageFileMachine.AMD64;
+                            try {
+                                int machine = (int)new Int32Converter().ConvertFromInvariantString(plat);
+                                Platform = PortableExecutableKinds.ILOnly;
+                                Machine = (ImageFileMachine)machine;
+                            } catch {
+                                goto case "anycpu";
+                            }
                             break;
                     }
                 } else if (arg.StartsWith("/win32icon:", StringComparison.Ordinal)) {
@@ -210,6 +243,8 @@ public void ParseArgs(IEnumerable<string> args, List<string> respFiles = null) {
                     foreach (var f in Directory.EnumerateFiles(Environment.CurrentDirectory, pattern)) {
                         Files.Add(Path.GetFullPath(f));
                     }
+                } else if (arg.Equals("/nologo", StringComparison.Ordinal)) {
+                    NoLogo = true;
                 } else if (Array.IndexOf(helpStrings, arg) >= 0) {
                     ConsoleOps.Usage(true);
                 } else if (arg.StartsWith("/py:", StringComparison.Ordinal)) {
@@ -306,12 +341,25 @@ public bool Validate() {
                 return false;
             }
 
-            if (string.IsNullOrWhiteSpace(Output) && !string.IsNullOrWhiteSpace(MainName)) {
-                Output = Path.GetFileNameWithoutExtension(MainName);
-                OutputPath = Path.GetDirectoryName(MainName);
-            } else if (string.IsNullOrWhiteSpace(Output) && Files != null && Files.Count > 0) {
-                Output = Path.GetFileNameWithoutExtension(Files[0]);
-                OutputPath = Path.GetDirectoryName(Files[0]);
+            if (string.IsNullOrWhiteSpace(Output)) {
+                if (!string.IsNullOrWhiteSpace(MainName)) {
+                    Output = Path.GetFileNameWithoutExtension(MainName);
+                    OutputPath = Path.GetDirectoryName(MainName);
+                } else if (Files != null && Files.Count > 0) {
+                    Output = Path.GetFileNameWithoutExtension(Files[0]);
+                    OutputPath = Path.GetDirectoryName(Files[0]);
+                }
+            }
+            else {
+                OutputPath = Path.GetDirectoryName(Output);
+                Output = Path.GetFileName(Output);
+                if (string.IsNullOrWhiteSpace(Output)) {
+                    if (!string.IsNullOrWhiteSpace(MainName)) {
+                        Output = Path.GetFileNameWithoutExtension(MainName);
+                    } else if (Files != null && Files.Count > 0) {
+                        Output = Path.GetFileNameWithoutExtension(Files[0]);
+                    }
+                }
             }
 
             if (!string.IsNullOrWhiteSpace(Win32Icon) && Target == PEFileKinds.Dll) {
@@ -334,7 +382,7 @@ public override string ToString() {
             res.AppendLine($"Output:\n\t{Output}");
             res.AppendLine($"OutputPath:\n\t{OutputPath}");
             res.AppendLine($"Target:\n\t{Target}");
-            res.AppendLine($"Platform:\n\t{Machine}");
+            res.AppendLine($"Platform:\n\t{Machine} ({Platform})");
             if (Target == PEFileKinds.WindowApplication) {
                 res.AppendLine("Threading:");
                 if (UseMta) {
diff --git a/src/executables/IronPython.Compiler/ConsoleOps.cs b/src/executables/IronPython.Compiler/ConsoleOps.cs
index eea8940e4..0be6a3d76 100644
--- a/src/executables/IronPython.Compiler/ConsoleOps.cs
+++ b/src/executables/IronPython.Compiler/ConsoleOps.cs
@@ -7,6 +7,8 @@
 namespace IronPython.Compiler {
     public static class ConsoleOps {
 
+        public static bool NoLogo { get; set; }
+
         public static void Error(string format, params object[] args) {
             Error(false, format, args);
         }
@@ -34,6 +36,7 @@ public static void Warning(string format, params object[] args) {
         }
 
         public static void Info(string format, params object[] args) {
+            if (NoLogo) { return; }
             Console.WriteLine(format, args);
         }
 
@@ -52,6 +55,7 @@ public static void Usage(bool doExit = false) {
     /productname:<productname>                Sets the product name attribute for the generated assembly
     /productversion:<productversion>          Sets the product version attribute for the generated assembly
     /py:<option>                              Allows specifying options that modify the behavior of IronPython (e.g., -X:FullFrames)
+    /nologo                                   Suppress compiler copyright message
     @<file>                                   Specifies a response file to be parsed for input files and command line options (one per line)
     /? /h                                     This message    
 
diff --git a/src/executables/IronPython.Compiler/IronPython.Compiler.csproj b/src/executables/IronPython.Compiler/IronPython.Compiler.csproj
index 1452938e1..dd5e47b57 100644
--- a/src/executables/IronPython.Compiler/IronPython.Compiler.csproj
+++ b/src/executables/IronPython.Compiler/IronPython.Compiler.csproj
@@ -5,6 +5,7 @@
     <OutputType>Exe</OutputType>
     <RootNamespace>IronPython.Compiler</RootNamespace>
     <AssemblyName>ipyc</AssemblyName>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <StartupObject>IronPython.Compiler.Program</StartupObject>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/executables/IronPython.Compiler/Program.cs b/src/executables/IronPython.Compiler/Program.cs
index 2caf6684e..ea83c7078 100644
--- a/src/executables/IronPython.Compiler/Program.cs
+++ b/src/executables/IronPython.Compiler/Program.cs
@@ -4,21 +4,19 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
-using System.Resources;
-
-using IKVM.Reflection;
-using IKVM.Reflection.Emit;
+using System.Reflection;
+using System.Reflection.Emit;
 
 using IronPython.Hosting;
 using IronPython.Runtime;
 using IronPython.Runtime.Operations;
 
+using Microsoft.Scripting.Generation;
 using Microsoft.Scripting.Hosting;
 using Microsoft.Scripting.Runtime;
 
-using Type = IKVM.Reflection.Type;
-
 namespace IronPython.Compiler {
 
     public class Program {
@@ -27,32 +25,10 @@ public class Program {
         /// Generates the stub .exe file for starting the app
         /// </summary>
         /// <param name="config"></param>
-        private static void GenerateExe(Config config) {
-            var u = new Universe();
-            var aName = new AssemblyName(Path.GetFileNameWithoutExtension(new FileInfo(config.Output).Name));
-            var ab = u.DefineDynamicAssembly(aName, AssemblyBuilderAccess.Save, config.OutputPath);
-            var mb = ab.DefineDynamicModule(config.Output, aName.Name + (aName.Name.EndsWith(".exe", StringComparison.Ordinal) ? string.Empty : ".exe"));
-            var tb = mb.DefineType("PythonMain", IKVM.Reflection.TypeAttributes.Public);
-
-            if (!string.IsNullOrEmpty(config.Win32Icon)) {
-                ab.__DefineIconResource(File.ReadAllBytes(config.Win32Icon));
-            }
-
-            var attributes = new List<Tuple<string, Type>> {
-                Tuple.Create(config.FileVersion, u.Import(typeof(System.Reflection.AssemblyFileVersionAttribute))),
-                Tuple.Create(config.ProductName, u.Import(typeof(System.Reflection.AssemblyProductAttribute))),
-                Tuple.Create(config.ProductVersion, u.Import(typeof(System.Reflection.AssemblyInformationalVersionAttribute))),
-                Tuple.Create(config.Copyright, u.Import(typeof(System.Reflection.AssemblyCopyrightAttribute)))
-            };
-
-            foreach (var attr in attributes) {
-                if (!string.IsNullOrWhiteSpace(config.FileVersion)) {
-                    CustomAttributeBuilder builder = new CustomAttributeBuilder(attr.Item2.GetConstructor(new[] { u.Import(typeof(string)) }), new object[] { attr.Item1 });
-                    ab.SetCustomAttribute(builder);
-                }
-            }
-
-            ab.DefineVersionInfoResource();
+        private static void GenerateExe(AssemblyGen assemblyGen, Config config) {
+            var ab = assemblyGen.AssemblyBuilder;
+            var mb = assemblyGen.ModuleBuilder;
+            var tb = mb.DefineType("PythonMain", TypeAttributes.Public | TypeAttributes.Abstract | TypeAttributes.Sealed);
 
             MethodBuilder assemblyResolveMethod = null;
             ILGenerator gen = null;
@@ -72,12 +48,12 @@ private static void GenerateExe(Config config) {
                     "System.Runtime.CompilerServices.Unsafe",
                 };
 
-                foreach (var a in System.AppDomain.CurrentDomain.GetAssemblies()) {
+                foreach (var a in AppDomain.CurrentDomain.GetAssemblies()) {
                     var n = new AssemblyName(a.FullName);
                     if (!a.IsDynamic && a.EntryPoint == null && (n.Name.StartsWith("IronPython", StringComparison.Ordinal) || embedAssemblies.Contains(n.Name))) {
                         ConsoleOps.Info($"\tEmbedded {n.Name} {n.Version}");
                         var f = new FileStream(a.Location, FileMode.Open, FileAccess.Read);
-                        mb.DefineManifestResource("Dll." + n.Name, f, IKVM.Reflection.ResourceAttributes.Public);
+                        mb.DefineManifestResource("Dll." + n.Name, f, ResourceAttributes.Public);
                     }
                 }
 
@@ -85,74 +61,93 @@ private static void GenerateExe(Config config) {
                     var name = Path.GetFileNameWithoutExtension(dll);
                     ConsoleOps.Info($"\tEmbedded {name}");
                     var f = new FileStream(dll, FileMode.Open, FileAccess.Read);
-                    mb.DefineManifestResource("Dll." + name, f, IKVM.Reflection.ResourceAttributes.Public);
+                    mb.DefineManifestResource("Dll." + name, f, ResourceAttributes.Public);
                 }
 
                 // we currently do no error checking on what is passed in to the assemblyresolve event handler
-                assemblyResolveMethod = tb.DefineMethod("AssemblyResolve", MethodAttributes.Public | MethodAttributes.Static, u.Import(typeof(System.Reflection.Assembly)), new IKVM.Reflection.Type[] { u.Import(typeof(System.Object)), u.Import(typeof(System.ResolveEventArgs)) });
+                assemblyResolveMethod = tb.DefineMethod("AssemblyResolve", MethodAttributes.Public | MethodAttributes.Static, typeof(Assembly), new[] { typeof(object), typeof(ResolveEventArgs) });
                 gen = assemblyResolveMethod.GetILGenerator();
-                var s = gen.DeclareLocal(u.Import(typeof(System.IO.Stream))); // resource stream
 
-                gen.Emit(OpCodes.Ldnull);
-                gen.Emit(OpCodes.Stloc, s);
-                var d = gen.DeclareLocal(u.Import(typeof(byte[]))); // data buffer;
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Call, typeof(Assembly).GetMethod(nameof(Assembly.GetEntryAssembly)), Type.EmptyTypes);
                 gen.Emit(OpCodes.Ldstr, "Dll.");
                 gen.Emit(OpCodes.Ldarg_1);    // The event args
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.ResolveEventArgs)).GetMethod("get_Name"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Newobj, u.Import(typeof(System.Reflection.AssemblyName)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)) }));
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.AssemblyName)).GetMethod("get_Name"), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(string)).GetMethod("Concat", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)) }), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetManifestResourceStream", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Callvirt, typeof(ResolveEventArgs).GetProperty(nameof(ResolveEventArgs.Name)).GetGetMethod(), Type.EmptyTypes);
+
+                var s = gen.DeclareLocal(typeof(Stream)); // resource stream
+                gen.Emit(OpCodes.Newobj, typeof(AssemblyName).GetConstructor(new[] { typeof(string) }));
+                gen.EmitCall(OpCodes.Call, typeof(AssemblyName).GetProperty(nameof(AssemblyName.Name)).GetGetMethod(), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Call, typeof(string).GetMethod(nameof(string.Concat), new[] { typeof(string), typeof(string) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Callvirt, typeof(Assembly).GetMethod(nameof(Assembly.GetManifestResourceStream), new[] { typeof(string) }), Type.EmptyTypes);
                 gen.Emit(OpCodes.Stloc, s);
+
+                gen.BeginExceptionBlock();
+
+                var d = gen.DeclareLocal(typeof(byte[])); // data buffer;
                 gen.Emit(OpCodes.Ldloc, s);
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("get_Length"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Newarr, u.Import(typeof(System.Byte)));
+                gen.EmitCall(OpCodes.Callvirt, typeof(Stream).GetProperty(nameof(Stream.Length)).GetGetMethod(), Type.EmptyTypes);
+                gen.Emit(OpCodes.Newarr, typeof(byte));
                 gen.Emit(OpCodes.Stloc, d);
+
                 gen.Emit(OpCodes.Ldloc, s);
                 gen.Emit(OpCodes.Ldloc, d);
                 gen.Emit(OpCodes.Ldc_I4_0);
                 gen.Emit(OpCodes.Ldloc, s);
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("get_Length"), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Callvirt, typeof(Stream).GetProperty(nameof(Stream.Length)).GetGetMethod(), Type.EmptyTypes);
                 gen.Emit(OpCodes.Conv_I4);
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.IO.Stream)).GetMethod("Read", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])), u.Import(typeof(int)), u.Import(typeof(int)) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Callvirt, typeof(Stream).GetMethod(nameof(Stream.Read), new[] { typeof(byte[]), typeof(int), typeof(int) }), Type.EmptyTypes);
                 gen.Emit(OpCodes.Pop);
+
+                var aa = gen.DeclareLocal(typeof(Assembly));
                 gen.Emit(OpCodes.Ldloc, d);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("Load", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Call, typeof(Assembly).GetMethod(nameof(Assembly.Load), new[] { typeof(byte[]) }), Type.EmptyTypes);
+                gen.Emit(OpCodes.Stloc, aa);
+
+                gen.BeginFinallyBlock();
+
+                gen.Emit(OpCodes.Ldloc, s);
+                var offset = gen.ILOffset;
+                gen.Emit(OpCodes.Brfalse_S, (byte)6);
+
+                gen.Emit(OpCodes.Ldloc, s);
+                gen.EmitCall(OpCodes.Callvirt, typeof(Stream).GetMethod(nameof(Stream.Dispose)), Type.EmptyTypes);
+
+                gen.EndExceptionBlock();
+
+                gen.Emit(OpCodes.Ldloc, aa);
                 gen.Emit(OpCodes.Ret);
 
                 // generate a static constructor to assign the AssemblyResolve handler (otherwise it tries to use IronPython before it adds the handler)
                 // the other way of handling this would be to move the call to InitializeModule into a separate method.
                 var staticConstructor = tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, Type.EmptyTypes);
                 gen = staticConstructor.GetILGenerator();
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.AppDomain)).GetMethod("get_CurrentDomain"), Type.EmptyTypes);
+
+                gen.EmitCall(OpCodes.Call, typeof(AppDomain).GetProperty(nameof(AppDomain.CurrentDomain)).GetGetMethod(), Type.EmptyTypes);
                 gen.Emit(OpCodes.Ldnull);
                 gen.Emit(OpCodes.Ldftn, assemblyResolveMethod);
-                gen.Emit(OpCodes.Newobj, u.Import(typeof(System.ResolveEventHandler)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(object)), u.Import(typeof(System.IntPtr)) }));
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.AppDomain)).GetMethod("add_AssemblyResolve"), Type.EmptyTypes);
+                gen.Emit(OpCodes.Newobj, typeof(ResolveEventHandler).GetConstructor(new[] { typeof(object), typeof(nint) }));
+                gen.EmitCall(OpCodes.Callvirt, typeof(AppDomain).GetEvent(nameof(AppDomain.AssemblyResolve)).GetAddMethod(), Type.EmptyTypes);
                 gen.Emit(OpCodes.Ret);
             }
 
-            var mainMethod = tb.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, u.Import(typeof(int)), Type.EmptyTypes);
+            var mainMethod = tb.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(int), Type.EmptyTypes);
             if (config.Target == PEFileKinds.WindowApplication && config.UseMta) {
-                mainMethod.SetCustomAttribute(u.Import(typeof(System.MTAThreadAttribute)).GetConstructor(Type.EmptyTypes), Array.Empty<byte>());
+                mainMethod.SetCustomAttribute(typeof(MTAThreadAttribute).GetConstructor(Type.EmptyTypes), Array.Empty<byte>());
             } else if (config.Target == PEFileKinds.WindowApplication || config.Target == PEFileKinds.ConsoleApplication && config.UseSta) {
-                mainMethod.SetCustomAttribute(u.Import(typeof(System.STAThreadAttribute)).GetConstructor(Type.EmptyTypes), Array.Empty<byte>());
+                mainMethod.SetCustomAttribute(typeof(STAThreadAttribute).GetConstructor(Type.EmptyTypes), Array.Empty<byte>());
             }
 
             gen = mainMethod.GetILGenerator();
 
-            // variables for saving original working directory and return code of script
-            var strVar = gen.DeclareLocal(u.Import(typeof(string)));
-            var intVar = gen.DeclareLocal(u.Import(typeof(int)));
+            // variables for saving return code of script
+            var intVar = gen.DeclareLocal(typeof(int));
             LocalBuilder dictVar = null;
 
             if (config.PythonOptions.Count > 0) {
-                var True = u.Import(typeof(ScriptingRuntimeHelpers)).GetField("True");
-                var False = u.Import(typeof(ScriptingRuntimeHelpers)).GetField("False");
+                var True = typeof(ScriptingRuntimeHelpers).GetField(nameof(ScriptingRuntimeHelpers.True));
+                var False = typeof(ScriptingRuntimeHelpers).GetField(nameof(ScriptingRuntimeHelpers.False));
 
-                dictVar = gen.DeclareLocal(u.Import(typeof(Dictionary<string, object>)));
-                gen.Emit(OpCodes.Newobj, u.Import(typeof(Dictionary<string, object>)).GetConstructor(Type.EmptyTypes));
+                dictVar = gen.DeclareLocal(typeof(Dictionary<string, object>));
+                gen.Emit(OpCodes.Newobj, typeof(Dictionary<string, object>).GetConstructor(Type.EmptyTypes));
                 gen.Emit(OpCodes.Stloc, dictVar);
 
                 foreach (var option in config.PythonOptions) {
@@ -163,59 +158,22 @@ private static void GenerateExe(Config config) {
                             gen.Emit(OpCodes.Ldc_I4_S, val); // this is more optimized
                         else
                             gen.Emit(OpCodes.Ldc_I4, val);
-                        gen.Emit(OpCodes.Box, u.Import(typeof(System.Int32)));
+                        gen.Emit(OpCodes.Box, typeof(int));
                     } else if (option.Value.Equals(ScriptingRuntimeHelpers.True)) {
                         gen.Emit(OpCodes.Ldsfld, True);
                     } else if (option.Value.Equals(ScriptingRuntimeHelpers.False)) {
                         gen.Emit(OpCodes.Ldsfld, False);
                     }
-                    gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(Dictionary<string, object>)).GetMethod("Add", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(object)) }), Type.EmptyTypes);
+                    gen.EmitCall(OpCodes.Callvirt, typeof(Dictionary<string, object>).GetMethod(nameof(Dictionary<string, object>.Add), new[] { typeof(string), typeof(object) }), Type.EmptyTypes);
                 }
             }
 
-            Label tryStart = gen.BeginExceptionBlock();
+            gen.BeginExceptionBlock();
 
             // get the ScriptCode assembly...
-            if (config.Embed) {
-                // put the generated DLL into the resources for the stub exe
-                var mem = new MemoryStream();
-                var rw = new ResourceWriter(mem);
-                rw.AddResource("IPDll." + Path.GetFileNameWithoutExtension(config.Output) + ".dll", File.ReadAllBytes(Path.Combine(config.OutputPath, config.Output) + ".dll"));
-                rw.Generate();
-                mem.Position = 0;
-                mb.DefineManifestResource("IPDll.resources", mem, ResourceAttributes.Public);
-                File.Delete(Path.Combine(config.OutputPath, config.Output) + ".dll");
-
-                // generate code to load the resource
-                gen.Emit(OpCodes.Ldstr, "IPDll");
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Newobj, u.Import(typeof(System.Resources.ResourceManager)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(System.Reflection.Assembly)) }));
-                gen.Emit(OpCodes.Ldstr, "IPDll." + Path.GetFileNameWithoutExtension(config.Output) + ".dll");
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Resources.ResourceManager)).GetMethod("GetObject", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("Load", new IKVM.Reflection.Type[] { u.Import(typeof(byte[])) }), Type.EmptyTypes);
-            } else {
-                // save current working directory
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("get_CurrentDirectory"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Stloc, strVar);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("GetEntryAssembly"), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Reflection.Assembly)).GetMethod("get_Location"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Newobj, u.Import(typeof(System.IO.FileInfo)).GetConstructor(new IKVM.Reflection.Type[] { u.Import(typeof(string)) }));
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.FileInfo)).GetMethod("get_Directory"), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.DirectoryInfo)).GetMethod("get_FullName"), Type.EmptyTypes);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("set_CurrentDirectory"), Type.EmptyTypes);
-                gen.Emit(OpCodes.Ldstr, config.Output + ".dll");
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.IO.Path)).GetMethod("GetFullPath", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
-                // result of GetFullPath stays on the stack during the restore of the
-                // original working directory
-
-                // restore original working directory
-                gen.Emit(OpCodes.Ldloc, strVar);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Environment)).GetMethod("set_CurrentDirectory"), Type.EmptyTypes);
-
-                // for the LoadFile() call, the full path of the assembly is still is on the stack
-                // as the result from the call to GetFullPath()
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Reflection.Assembly)).GetMethod("LoadFile", new IKVM.Reflection.Type[] { u.Import(typeof(string)) }), Type.EmptyTypes);
-            }
+            gen.Emit(OpCodes.Ldtoken, tb);
+            gen.EmitCall(OpCodes.Call, typeof(Type).GetMethod(nameof(Type.GetTypeFromHandle)), new[] { typeof(RuntimeTypeHandle) });
+            gen.EmitCall(OpCodes.Callvirt, typeof(Type).GetProperty(nameof(Type.Assembly)).GetGetMethod(), Type.EmptyTypes);
 
             // emit module name
             gen.Emit(OpCodes.Ldstr, "__main__");  // main module name
@@ -230,29 +188,25 @@ private static void GenerateExe(Config config) {
             // call InitializeModuleEx
             // (this will also run the script)
             // and put the return code on the stack
-            gen.EmitCall(OpCodes.Call, u.Import(typeof(PythonOps)).GetMethod(nameof(PythonOps.InitializeModuleEx),
-                new IKVM.Reflection.Type[] { u.Import(typeof(System.Reflection.Assembly)), u.Import(typeof(string)), u.Import(typeof(string[])), u.Import(typeof(bool)), u.Import(typeof(Dictionary<string, object>)) }),
+            gen.EmitCall(OpCodes.Call, typeof(PythonOps).GetMethod(nameof(PythonOps.InitializeModuleEx),
+                new[] { typeof(Assembly), typeof(string), typeof(string[]), typeof(bool), typeof(Dictionary<string, object>) }),
                 Type.EmptyTypes);
             gen.Emit(OpCodes.Stloc, intVar);
-            gen.BeginCatchBlock(u.Import(typeof(Exception)));
+            gen.BeginCatchBlock(typeof(Exception));
+
+            var strVar = gen.DeclareLocal(typeof(string));
+            gen.EmitCall(OpCodes.Callvirt, typeof(Exception).GetProperty(nameof(Exception.Message)).GetGetMethod(), Type.EmptyTypes);
+            gen.Emit(OpCodes.Stloc, strVar);
 
             if (config.Target == PEFileKinds.ConsoleApplication) {
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Exception)).GetMethod("get_Message", Type.EmptyTypes), Type.EmptyTypes);
-                gen.Emit(OpCodes.Stloc, strVar);
                 gen.Emit(OpCodes.Ldstr, config.ErrorMessageFormat);
                 gen.Emit(OpCodes.Ldloc, strVar);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Console)).GetMethod("WriteLine", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Call, typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string), typeof(string) }), Type.EmptyTypes);
             } else {
-                gen.EmitCall(OpCodes.Callvirt, u.Import(typeof(System.Exception)).GetMethod("get_Message", Type.EmptyTypes), Type.EmptyTypes);
-                gen.Emit(OpCodes.Stloc, strVar);
                 gen.Emit(OpCodes.Ldstr, config.ErrorMessageFormat);
                 gen.Emit(OpCodes.Ldloc, strVar);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(string)).GetMethod("Format", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)) }), Type.EmptyTypes);
-                gen.Emit(OpCodes.Ldstr, "Error");
-                gen.Emit(OpCodes.Ldc_I4, (int)System.Windows.Forms.MessageBoxButtons.OK);
-                gen.Emit(OpCodes.Ldc_I4, (int)System.Windows.Forms.MessageBoxIcon.Error);
-                gen.EmitCall(OpCodes.Call, u.Import(typeof(System.Windows.Forms.MessageBox)).GetMethod("Show", new IKVM.Reflection.Type[] { u.Import(typeof(string)), u.Import(typeof(string)), u.Import(typeof(System.Windows.Forms.MessageBoxButtons)), u.Import(typeof(System.Windows.Forms.MessageBoxIcon)) }), Type.EmptyTypes);
-                gen.Emit(OpCodes.Pop);
+                gen.EmitCall(OpCodes.Call, typeof(string).GetMethod(nameof(string.Format), new[] { typeof(string), typeof(string) }), Type.EmptyTypes);
+                gen.EmitCall(OpCodes.Call, typeof(Debug).GetMethod(nameof(Debug.WriteLine), new[] { typeof(string) }), Type.EmptyTypes);
             }
 
             gen.Emit(OpCodes.Ldc_I4, -1); // return code is -1 to show failure
@@ -265,17 +219,15 @@ private static void GenerateExe(Config config) {
 
             tb.CreateType();
             ab.SetEntryPoint(mainMethod, config.Target);
-            string fileName = aName.Name.EndsWith(".exe", StringComparison.Ordinal) ? aName.Name : aName.Name + ".exe";
-            ab.Save(fileName, config.Platform, config.Machine);
         }
 
         public static int Main(string[] args) {
-            var files = new List<string>();
             var config = new Config();
             config.ParseArgs(args);
             if (!config.Validate()) {
                 ConsoleOps.Usage(true);
             }
+            ConsoleOps.NoLogo = config.NoLogo;
 
             // we don't use the engine, but we create it so we can have a default context.
             ScriptEngine engine = Python.CreateEngine(config.PythonOptions);
@@ -293,17 +245,30 @@ public static int Main(string[] args) {
             };
 
             try {
-                ClrModule.CompileModules(DefaultContext.DefaultCLS,
-                    Path.Combine(config.OutputPath, Path.ChangeExtension(config.Output, ".dll")),
+                string outputFileName = Path.Combine(config.OutputPath, config.Output);
+
+                if (!Path.HasExtension(outputFileName)) {
+                    outputFileName = config.Target == PEFileKinds.Dll
+                        ? Path.ChangeExtension(outputFileName, ".dll")
+                        : Path.ChangeExtension(outputFileName, ".exe");
+                }
+
+                var ag = ClrModule.CreateAssemblyGen(DefaultContext.DefaultCLS,
+                    outputFileName,
                     compileOptions,
                     config.Files.ToArray());
 
-                var outputfilename = Path.Combine(config.OutputPath, Path.ChangeExtension(config.Output, ".dll"));
                 if (config.Target != PEFileKinds.Dll) {
-                    outputfilename = Path.Combine(config.OutputPath, Path.ChangeExtension(config.Output, ".exe"));
-                    GenerateExe(config);
+                    GenerateExe(ag, config);
                 }
-                ConsoleOps.Info($"Saved to {outputfilename}");
+
+                ag.AssemblyBuilder.Save(Path.GetFileName(outputFileName), config.Platform, config.Machine);
+
+                if (config.Target != PEFileKinds.Dll && !string.IsNullOrEmpty(config.Win32Icon)) {
+                    IconInjector.InjectIcon(outputFileName, config.Win32Icon);
+                }
+
+                ConsoleOps.Info($"Saved to {outputFileName}");
             } catch (Exception e) {
                 Console.WriteLine();
                 ConsoleOps.Error(true, e.Message);
diff --git a/src/executables/IronPython.Compiler/README.md b/src/executables/IronPython.Compiler/README.md
index b25d92298..7c2d1fe2d 100644
--- a/src/executables/IronPython.Compiler/README.md
+++ b/src/executables/IronPython.Compiler/README.md
@@ -23,6 +23,8 @@ Options:
 
     /py:<option>                              Allows specifying options that modify the behavior of IronPython (e.g., -X:FullFrames)
 
+    /nologo                                   Suppress compiler copyright message
+
     @<file>                                   Specifies a response file to be parsed for input files and command line options (one per line)
 
     /? /h                                     This message