diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig
index a002c9c61574..7b8ad93547e3 100644
--- a/lib/compiler/resinator/cli.zig
+++ b/lib/compiler/resinator/cli.zig
@@ -5,6 +5,7 @@ const lang = @import("lang.zig");
 const res = @import("res.zig");
 const Allocator = std.mem.Allocator;
 const lex = @import("lex.zig");
+const cvtres = @import("cvtres.zig");
 
 /// This is what /SL 100 will set the maximum string literal length to
 pub const max_string_literal_length_100_percent = 8192;
@@ -59,6 +60,20 @@ pub const usage_string_after_command_name =
     \\                            the .rc includes or otherwise depends on.
     \\  /:depfile-fmt <value>     Output format of the depfile, if /:depfile is set.
     \\    json                    (default) A top-level JSON array of paths
+    \\  /:input-format <value>    If not specified, the input format is inferred.
+    \\    rc                      (default if input format cannot be inferred)
+    \\    res                     Compiled .rc file, implies /:output-format coff
+    \\    rcpp                    Preprocessed .rc file, implies /:no-preprocess
+    \\  /:output-format <value>   If not specified, the output format is inferred.
+    \\    res                     (default if output format cannot be inferred)
+    \\    coff                    COFF object file (extension: .obj or .o)
+    \\    rcpp                    Preprocessed .rc file, implies /p
+    \\  /:target <arch>           Set the target machine for COFF object files.
+    \\                            Can be specified either as PE/COFF machine constant
+    \\                            name (X64, ARM64, etc) or Zig/LLVM CPU name (x86_64,
+    \\                            aarch64, etc). The default is X64 (aka x86_64).
+    \\                            Also accepts a full Zig/LLVM triple, but everything
+    \\                            except the architecture is ignored.
     \\
     \\Note: For compatibility reasons, all custom options start with :
     \\
@@ -131,8 +146,8 @@ pub const Diagnostics = struct {
 
 pub const Options = struct {
     allocator: Allocator,
-    input_filename: []const u8 = &[_]u8{},
-    output_filename: []const u8 = &[_]u8{},
+    input_source: IoSource = .{ .filename = &[_]u8{} },
+    output_source: IoSource = .{ .filename = &[_]u8{} },
     extra_include_paths: std.ArrayListUnmanaged([]const u8) = .empty,
     ignore_include_env_var: bool = false,
     preprocess: Preprocess = .yes,
@@ -149,9 +164,30 @@ pub const Options = struct {
     auto_includes: AutoIncludes = .any,
     depfile_path: ?[]const u8 = null,
     depfile_fmt: DepfileFormat = .json,
+    input_format: InputFormat = .rc,
+    output_format: OutputFormat = .res,
+    coff_options: cvtres.CoffOptions = .{},
 
+    pub const IoSource = union(enum) {
+        stdio: std.fs.File,
+        filename: []const u8,
+    };
     pub const AutoIncludes = enum { any, msvc, gnu, none };
     pub const DepfileFormat = enum { json };
+    pub const InputFormat = enum { rc, res, rcpp };
+    pub const OutputFormat = enum {
+        res,
+        coff,
+        rcpp,
+
+        pub fn extension(format: OutputFormat) []const u8 {
+            return switch (format) {
+                .rcpp => ".rcpp",
+                .coff => ".obj",
+                .res => ".res",
+            };
+        }
+    };
     pub const Preprocess = enum { no, yes, only };
     pub const SymbolAction = enum { define, undefine };
     pub const SymbolValue = union(SymbolAction) {
@@ -198,9 +234,10 @@ pub const Options = struct {
         try self.symbols.put(self.allocator, duped_key, .{ .undefine = {} });
     }
 
-    /// If the current input filename both:
+    /// If the current input filename:
     /// - does not have an extension, and
-    /// - does not exist in the cwd
+    /// - does not exist in the cwd, and
+    /// - the input format is .rc
     /// then this function will append `.rc` to the input filename
     ///
     /// Note: This behavior is different from the Win32 compiler.
@@ -213,14 +250,18 @@ pub const Options = struct {
     /// of the .rc extension being omitted from the CLI args, but still
     /// work fine if the file itself does not have an extension.
     pub fn maybeAppendRC(options: *Options, cwd: std.fs.Dir) !void {
-        if (std.fs.path.extension(options.input_filename).len == 0) {
-            cwd.access(options.input_filename, .{}) catch |err| switch (err) {
+        switch (options.input_source) {
+            .stdio => return,
+            .filename => {},
+        }
+        if (options.input_format == .rc and std.fs.path.extension(options.input_source.filename).len == 0) {
+            cwd.access(options.input_source.filename, .{}) catch |err| switch (err) {
                 error.FileNotFound => {
-                    var filename_bytes = try options.allocator.alloc(u8, options.input_filename.len + 3);
-                    @memcpy(filename_bytes[0..options.input_filename.len], options.input_filename);
+                    var filename_bytes = try options.allocator.alloc(u8, options.input_source.filename.len + 3);
+                    @memcpy(filename_bytes[0..options.input_source.filename.len], options.input_source.filename);
                     @memcpy(filename_bytes[filename_bytes.len - 3 ..], ".rc");
-                    options.allocator.free(options.input_filename);
-                    options.input_filename = filename_bytes;
+                    options.allocator.free(options.input_source.filename);
+                    options.input_source = .{ .filename = filename_bytes };
                 },
                 else => {},
             };
@@ -232,8 +273,14 @@ pub const Options = struct {
             self.allocator.free(extra_include_path);
         }
         self.extra_include_paths.deinit(self.allocator);
-        self.allocator.free(self.input_filename);
-        self.allocator.free(self.output_filename);
+        switch (self.input_source) {
+            .stdio => {},
+            .filename => |filename| self.allocator.free(filename),
+        }
+        switch (self.output_source) {
+            .stdio => {},
+            .filename => |filename| self.allocator.free(filename),
+        }
         var symbol_it = self.symbols.iterator();
         while (symbol_it.next()) |entry| {
             self.allocator.free(entry.key_ptr.*);
@@ -243,11 +290,26 @@ pub const Options = struct {
         if (self.depfile_path) |depfile_path| {
             self.allocator.free(depfile_path);
         }
+        if (self.coff_options.define_external_symbol) |symbol_name| {
+            self.allocator.free(symbol_name);
+        }
     }
 
     pub fn dumpVerbose(self: *const Options, writer: anytype) !void {
-        try writer.print("Input filename: {s}\n", .{self.input_filename});
-        try writer.print("Output filename: {s}\n", .{self.output_filename});
+        const input_source_name = switch (self.input_source) {
+            .stdio => "<stdin>",
+            .filename => |filename| filename,
+        };
+        const output_source_name = switch (self.output_source) {
+            .stdio => "<stdout>",
+            .filename => |filename| filename,
+        };
+        try writer.print("Input filename: {s} (format={s})\n", .{ input_source_name, @tagName(self.input_format) });
+        try writer.print("Output filename: {s} (format={s})\n", .{ output_source_name, @tagName(self.output_format) });
+        if (self.output_format == .coff) {
+            try writer.print(" Target machine type for COFF: {s}\n", .{@tagName(self.coff_options.target)});
+        }
+
         if (self.extra_include_paths.items.len > 0) {
             try writer.writeAll(" Extra include paths:\n");
             for (self.extra_include_paths.items) |extra_include_path| {
@@ -331,6 +393,7 @@ pub const Arg = struct {
     }
 
     pub fn optionWithoutPrefix(self: Arg, option_len: usize) []const u8 {
+        if (option_len == 0) return self.name();
         return self.name()[0..option_len];
     }
 
@@ -380,6 +443,8 @@ pub const Arg = struct {
 
     pub const Value = struct {
         slice: []const u8,
+        /// Amount to increment the arg index to skip over both the option and the value arg(s)
+        /// e.g. 1 if /<option><value>, 2 if /<option> <value>
         index_increment: u2 = 1,
 
         pub fn argSpan(self: Value, arg: Arg) Diagnostics.ErrorDetails.ArgSpan {
@@ -414,6 +479,7 @@ pub const Arg = struct {
 
     pub const Context = struct {
         index: usize,
+        option_len: usize,
         arg: Arg,
         value: Value,
     };
@@ -428,7 +494,18 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
     errdefer options.deinit();
 
     var output_filename: ?[]const u8 = null;
-    var output_filename_context: Arg.Context = undefined;
+    var output_filename_context: union(enum) {
+        unspecified: void,
+        positional: usize,
+        arg: Arg.Context,
+    } = .{ .unspecified = {} };
+    var output_format: ?Options.OutputFormat = null;
+    var output_format_context: Arg.Context = undefined;
+    var input_format: ?Options.InputFormat = null;
+    var input_format_context: Arg.Context = undefined;
+    var input_filename_arg_i: usize = undefined;
+    var preprocess_only_context: Arg.Context = undefined;
+    var depfile_context: Arg.Context = undefined;
 
     var arg_i: usize = 0;
     next_arg: while (arg_i < args.len) {
@@ -470,6 +547,25 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
             if (std.ascii.startsWithIgnoreCase(arg_name, ":no-preprocess")) {
                 options.preprocess = .no;
                 arg.name_offset += ":no-preprocess".len;
+            } else if (std.ascii.startsWithIgnoreCase(arg_name, ":output-format")) {
+                const value = arg.value(":output-format".len, arg_i, args) catch {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("missing value after {s}{s} option", .{ arg.prefixSlice(), arg.optionWithoutPrefix(":output-format".len) });
+                    try diagnostics.append(err_details);
+                    arg_i += 1;
+                    break :next_arg;
+                };
+                output_format = std.meta.stringToEnum(Options.OutputFormat, value.slice) orelse blk: {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = value.argSpan(arg) };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("invalid output format setting: {s} ", .{value.slice});
+                    try diagnostics.append(err_details);
+                    break :blk output_format;
+                };
+                output_format_context = .{ .index = arg_i, .option_len = ":output-format".len, .arg = arg, .value = value };
+                arg_i += value.index_increment;
+                continue :next_arg;
             } else if (std.ascii.startsWithIgnoreCase(arg_name, ":auto-includes")) {
                 const value = arg.value(":auto-includes".len, arg_i, args) catch {
                     var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };
@@ -488,6 +584,25 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
                 };
                 arg_i += value.index_increment;
                 continue :next_arg;
+            } else if (std.ascii.startsWithIgnoreCase(arg_name, ":input-format")) {
+                const value = arg.value(":input-format".len, arg_i, args) catch {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("missing value after {s}{s} option", .{ arg.prefixSlice(), arg.optionWithoutPrefix(":input-format".len) });
+                    try diagnostics.append(err_details);
+                    arg_i += 1;
+                    break :next_arg;
+                };
+                input_format = std.meta.stringToEnum(Options.InputFormat, value.slice) orelse blk: {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = value.argSpan(arg) };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("invalid input format setting: {s} ", .{value.slice});
+                    try diagnostics.append(err_details);
+                    break :blk input_format;
+                };
+                input_format_context = .{ .index = arg_i, .option_len = ":input-format".len, .arg = arg, .value = value };
+                arg_i += value.index_increment;
+                continue :next_arg;
             } else if (std.ascii.startsWithIgnoreCase(arg_name, ":depfile-fmt")) {
                 const value = arg.value(":depfile-fmt".len, arg_i, args) catch {
                     var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };
@@ -522,6 +637,31 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
                 const path = try allocator.dupe(u8, value.slice);
                 errdefer allocator.free(path);
                 options.depfile_path = path;
+                depfile_context = .{ .index = arg_i, .option_len = ":depfile".len, .arg = arg, .value = value };
+                arg_i += value.index_increment;
+                continue :next_arg;
+            } else if (std.ascii.startsWithIgnoreCase(arg_name, ":target")) {
+                const value = arg.value(":target".len, arg_i, args) catch {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = arg.missingSpan() };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("missing value after {s}{s} option", .{ arg.prefixSlice(), arg.optionWithoutPrefix(":target".len) });
+                    try diagnostics.append(err_details);
+                    arg_i += 1;
+                    break :next_arg;
+                };
+                // Take the substring up to the first dash so that a full target triple
+                // can be used, e.g. x86_64-windows-gnu becomes x86_64
+                var target_it = std.mem.splitScalar(u8, value.slice, '-');
+                const arch_str = target_it.first();
+                const arch = cvtres.supported_targets.Arch.fromStringIgnoreCase(arch_str) orelse {
+                    var err_details = Diagnostics.ErrorDetails{ .arg_index = arg_i, .arg_span = value.argSpan(arg) };
+                    var msg_writer = err_details.msg.writer(allocator);
+                    try msg_writer.print("invalid or unsupported target architecture: {s}", .{arch_str});
+                    try diagnostics.append(err_details);
+                    arg_i += value.index_increment;
+                    continue :next_arg;
+                };
+                options.coff_options.target = arch.toCoffMachineType();
                 arg_i += value.index_increment;
                 continue :next_arg;
             } else if (std.ascii.startsWithIgnoreCase(arg_name, "nologo")) {
@@ -620,7 +760,7 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
                     arg_i += 1;
                     break :next_arg;
                 };
-                output_filename_context = .{ .index = arg_i, .arg = arg, .value = value };
+                output_filename_context = .{ .arg = .{ .index = arg_i, .option_len = "fo".len, .arg = arg, .value = value } };
                 output_filename = value.slice;
                 arg_i += value.index_increment;
                 continue :next_arg;
@@ -812,6 +952,7 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
                 arg.name_offset += 1;
             } else if (std.ascii.startsWithIgnoreCase(arg_name, "p")) {
                 options.preprocess = .only;
+                preprocess_only_context = .{ .index = arg_i, .option_len = "p".len, .arg = arg, .value = undefined };
                 arg.name_offset += 1;
             } else if (std.ascii.startsWithIgnoreCase(arg_name, "i")) {
                 const value = arg.value(1, arg_i, args) catch {
@@ -920,10 +1061,10 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
 
         if (args.len > 0) {
             const last_arg = args[args.len - 1];
-            if (arg_i > 0 and last_arg.len > 0 and last_arg[0] == '/' and std.ascii.endsWithIgnoreCase(last_arg, ".rc")) {
+            if (arg_i > 0 and last_arg.len > 0 and last_arg[0] == '/' and isSupportedInputExtension(std.fs.path.extension(last_arg))) {
                 var note_details = Diagnostics.ErrorDetails{ .type = .note, .print_args = true, .arg_index = arg_i - 1 };
                 var note_writer = note_details.msg.writer(allocator);
-                try note_writer.writeAll("if this argument was intended to be the input filename, then -- should be specified in front of it to exclude it from option parsing");
+                try note_writer.writeAll("if this argument was intended to be the input filename, adding -- in front of it will exclude it from option parsing");
                 try diagnostics.append(note_details);
             }
         }
@@ -932,7 +1073,28 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
         // things after this rely on the value of the input filename.
         return error.ParseError;
     }
-    options.input_filename = try allocator.dupe(u8, positionals[0]);
+    options.input_source = .{ .filename = try allocator.dupe(u8, positionals[0]) };
+    input_filename_arg_i = arg_i;
+
+    const InputFormatSource = enum {
+        inferred_from_input_filename,
+        input_format_arg,
+    };
+
+    var input_format_source: InputFormatSource = undefined;
+    if (input_format == null) {
+        const ext = std.fs.path.extension(options.input_source.filename);
+        if (std.ascii.eqlIgnoreCase(ext, ".res")) {
+            input_format = .res;
+        } else if (std.ascii.eqlIgnoreCase(ext, ".rcpp")) {
+            input_format = .rcpp;
+        } else {
+            input_format = .rc;
+        }
+        input_format_source = .inferred_from_input_filename;
+    } else {
+        input_format_source = .input_format_arg;
+    }
 
     if (positionals.len > 1) {
         if (output_filename != null) {
@@ -942,53 +1104,233 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
             try diagnostics.append(err_details);
             var note_details = Diagnostics.ErrorDetails{
                 .type = .note,
-                .arg_index = output_filename_context.value.index(output_filename_context.index),
-                .arg_span = output_filename_context.value.argSpan(output_filename_context.arg),
+                .arg_index = output_filename_context.arg.index,
+                .arg_span = output_filename_context.arg.value.argSpan(output_filename_context.arg.arg),
             };
             var note_writer = note_details.msg.writer(allocator);
             try note_writer.writeAll("output filename previously specified here");
             try diagnostics.append(note_details);
         } else {
             output_filename = positionals[1];
+            output_filename_context = .{ .positional = arg_i + 1 };
         }
     }
+
+    const OutputFormatSource = enum {
+        inferred_from_input_filename,
+        inferred_from_output_filename,
+        output_format_arg,
+        unable_to_infer_from_input_filename,
+        unable_to_infer_from_output_filename,
+        inferred_from_preprocess_only,
+    };
+
+    var output_format_source: OutputFormatSource = undefined;
     if (output_filename == null) {
-        var buf = std.ArrayList(u8).init(allocator);
-        errdefer buf.deinit();
-
-        if (std.fs.path.dirname(options.input_filename)) |dirname| {
-            var end_pos = dirname.len;
-            // We want to ensure that we write a path separator at the end, so if the dirname
-            // doesn't end with a path sep then include the char after the dirname
-            // which must be a path sep.
-            if (!std.fs.path.isSep(dirname[dirname.len - 1])) end_pos += 1;
-            try buf.appendSlice(options.input_filename[0..end_pos]);
+        if (output_format == null) {
+            output_format_source = .inferred_from_input_filename;
+            const input_ext = std.fs.path.extension(options.input_source.filename);
+            if (std.ascii.eqlIgnoreCase(input_ext, ".res")) {
+                output_format = .coff;
+            } else if (options.preprocess == .only and (input_format.? == .rc or std.ascii.eqlIgnoreCase(input_ext, ".rc"))) {
+                output_format = .rcpp;
+                output_format_source = .inferred_from_preprocess_only;
+            } else {
+                if (!std.ascii.eqlIgnoreCase(input_ext, ".res")) {
+                    output_format_source = .unable_to_infer_from_input_filename;
+                }
+                output_format = .res;
+            }
         }
-        try buf.appendSlice(std.fs.path.stem(options.input_filename));
-        if (options.preprocess == .only) {
-            try buf.appendSlice(".rcpp");
+        options.output_source = .{ .filename = try filepathWithExtension(allocator, options.input_source.filename, output_format.?.extension()) };
+    } else {
+        options.output_source = .{ .filename = try allocator.dupe(u8, output_filename.?) };
+        if (output_format == null) {
+            output_format_source = .inferred_from_output_filename;
+            const ext = std.fs.path.extension(options.output_source.filename);
+            if (std.ascii.eqlIgnoreCase(ext, ".obj") or std.ascii.eqlIgnoreCase(ext, ".o")) {
+                output_format = .coff;
+            } else if (std.ascii.eqlIgnoreCase(ext, ".rcpp")) {
+                output_format = .rcpp;
+            } else {
+                if (!std.ascii.eqlIgnoreCase(ext, ".res")) {
+                    output_format_source = .unable_to_infer_from_output_filename;
+                }
+                output_format = .res;
+            }
         } else {
-            try buf.appendSlice(".res");
+            output_format_source = .output_format_arg;
         }
+    }
 
-        options.output_filename = try buf.toOwnedSlice();
-    } else {
-        options.output_filename = try allocator.dupe(u8, output_filename.?);
+    options.input_format = input_format.?;
+    options.output_format = output_format.?;
+
+    // Check for incompatible options
+    var print_input_format_source_note: bool = false;
+    var print_output_format_source_note: bool = false;
+    if (options.depfile_path != null and (options.input_format == .res or options.output_format == .rcpp)) {
+        var err_details = Diagnostics.ErrorDetails{ .type = .warning, .arg_index = depfile_context.index, .arg_span = depfile_context.value.argSpan(depfile_context.arg) };
+        var msg_writer = err_details.msg.writer(allocator);
+        if (options.input_format == .res) {
+            try msg_writer.print("the {s}{s} option was ignored because the input format is '{s}'", .{
+                depfile_context.arg.prefixSlice(),
+                depfile_context.arg.optionWithoutPrefix(depfile_context.option_len),
+                @tagName(options.input_format),
+            });
+            print_input_format_source_note = true;
+        } else if (options.output_format == .rcpp) {
+            try msg_writer.print("the {s}{s} option was ignored because the output format is '{s}'", .{
+                depfile_context.arg.prefixSlice(),
+                depfile_context.arg.optionWithoutPrefix(depfile_context.option_len),
+                @tagName(options.output_format),
+            });
+            print_output_format_source_note = true;
+        }
+        try diagnostics.append(err_details);
+    }
+    if (!isSupportedTransformation(options.input_format, options.output_format)) {
+        var err_details = Diagnostics.ErrorDetails{ .arg_index = input_filename_arg_i, .print_args = false };
+        var msg_writer = err_details.msg.writer(allocator);
+        try msg_writer.print("input format '{s}' cannot be converted to output format '{s}'", .{ @tagName(options.input_format), @tagName(options.output_format) });
+        try diagnostics.append(err_details);
+        print_input_format_source_note = true;
+        print_output_format_source_note = true;
+    }
+    if (options.preprocess == .only and options.output_format != .rcpp) {
+        var err_details = Diagnostics.ErrorDetails{ .arg_index = preprocess_only_context.index };
+        var msg_writer = err_details.msg.writer(allocator);
+        try msg_writer.print("the {s}{s} option cannot be used with output format '{s}'", .{
+            preprocess_only_context.arg.prefixSlice(),
+            preprocess_only_context.arg.optionWithoutPrefix(preprocess_only_context.option_len),
+            @tagName(options.output_format),
+        });
+        try diagnostics.append(err_details);
+        print_output_format_source_note = true;
+    }
+    if (print_input_format_source_note) {
+        switch (input_format_source) {
+            .inferred_from_input_filename => {
+                var err_details = Diagnostics.ErrorDetails{ .type = .note, .arg_index = input_filename_arg_i };
+                var msg_writer = err_details.msg.writer(allocator);
+                try msg_writer.writeAll("the input format was inferred from the input filename");
+                try diagnostics.append(err_details);
+            },
+            .input_format_arg => {
+                var err_details = Diagnostics.ErrorDetails{
+                    .type = .note,
+                    .arg_index = input_format_context.index,
+                    .arg_span = input_format_context.value.argSpan(input_format_context.arg),
+                };
+                var msg_writer = err_details.msg.writer(allocator);
+                try msg_writer.writeAll("the input format was specified here");
+                try diagnostics.append(err_details);
+            },
+        }
+    }
+    if (print_output_format_source_note) {
+        switch (output_format_source) {
+            .inferred_from_input_filename, .unable_to_infer_from_input_filename => {
+                var err_details = Diagnostics.ErrorDetails{ .type = .note, .arg_index = input_filename_arg_i };
+                var msg_writer = err_details.msg.writer(allocator);
+                if (output_format_source == .inferred_from_input_filename) {
+                    try msg_writer.writeAll("the output format was inferred from the input filename");
+                } else {
+                    try msg_writer.writeAll("the output format was unable to be inferred from the input filename, so the default was used");
+                }
+                try diagnostics.append(err_details);
+            },
+            .inferred_from_output_filename, .unable_to_infer_from_output_filename => {
+                var err_details: Diagnostics.ErrorDetails = switch (output_filename_context) {
+                    .positional => |i| .{ .type = .note, .arg_index = i },
+                    .arg => |ctx| .{ .type = .note, .arg_index = ctx.index, .arg_span = ctx.value.argSpan(ctx.arg) },
+                    .unspecified => unreachable,
+                };
+                var msg_writer = err_details.msg.writer(allocator);
+                if (output_format_source == .inferred_from_output_filename) {
+                    try msg_writer.writeAll("the output format was inferred from the output filename");
+                } else {
+                    try msg_writer.writeAll("the output format was unable to be inferred from the output filename, so the default was used");
+                }
+                try diagnostics.append(err_details);
+            },
+            .output_format_arg => {
+                var err_details = Diagnostics.ErrorDetails{
+                    .type = .note,
+                    .arg_index = output_format_context.index,
+                    .arg_span = output_format_context.value.argSpan(output_format_context.arg),
+                };
+                var msg_writer = err_details.msg.writer(allocator);
+                try msg_writer.writeAll("the output format was specified here");
+                try diagnostics.append(err_details);
+            },
+            .inferred_from_preprocess_only => {
+                var err_details = Diagnostics.ErrorDetails{ .type = .note, .arg_index = preprocess_only_context.index };
+                var msg_writer = err_details.msg.writer(allocator);
+                try msg_writer.print("the output format was inferred from the usage of the {s}{s} option", .{
+                    preprocess_only_context.arg.prefixSlice(),
+                    preprocess_only_context.arg.optionWithoutPrefix(preprocess_only_context.option_len),
+                });
+                try diagnostics.append(err_details);
+            },
+        }
     }
 
     if (diagnostics.hasError()) {
         return error.ParseError;
     }
 
+    // Implied settings from input/output formats
+    if (options.output_format == .rcpp) options.preprocess = .only;
+    if (options.input_format == .res) options.output_format = .coff;
+    if (options.input_format == .rcpp) options.preprocess = .no;
+
     return options;
 }
 
+pub fn filepathWithExtension(allocator: Allocator, path: []const u8, ext: []const u8) ![]const u8 {
+    var buf = std.ArrayList(u8).init(allocator);
+    errdefer buf.deinit();
+    if (std.fs.path.dirname(path)) |dirname| {
+        var end_pos = dirname.len;
+        // We want to ensure that we write a path separator at the end, so if the dirname
+        // doesn't end with a path sep then include the char after the dirname
+        // which must be a path sep.
+        if (!std.fs.path.isSep(dirname[dirname.len - 1])) end_pos += 1;
+        try buf.appendSlice(path[0..end_pos]);
+    }
+    try buf.appendSlice(std.fs.path.stem(path));
+    try buf.appendSlice(ext);
+    return try buf.toOwnedSlice();
+}
+
 pub fn isSupportedInputExtension(ext: []const u8) bool {
     if (std.ascii.eqlIgnoreCase(ext, ".rc")) return true;
+    if (std.ascii.eqlIgnoreCase(ext, ".res")) return true;
     if (std.ascii.eqlIgnoreCase(ext, ".rcpp")) return true;
     return false;
 }
 
+pub fn isSupportedTransformation(input: Options.InputFormat, output: Options.OutputFormat) bool {
+    return switch (input) {
+        .rc => switch (output) {
+            .res => true,
+            .coff => true,
+            .rcpp => true,
+        },
+        .res => switch (output) {
+            .res => false,
+            .coff => true,
+            .rcpp => false,
+        },
+        .rcpp => switch (output) {
+            .res => true,
+            .coff => true,
+            .rcpp => false,
+        },
+    };
+}
+
 /// Returns true if the str is a valid C identifier for use in a #define/#undef macro
 pub fn isValidIdentifier(str: []const u8) bool {
     for (str, 0..) |c, i| switch (c) {
@@ -1278,17 +1620,6 @@ test "parse errors: basic" {
         \\
         \\
     );
-    try testParseError(&.{"/some/absolute/path/parsed/as/an/option.rc"},
-        \\<cli>: error: the /s option is unsupported
-        \\ ... /some/absolute/path/parsed/as/an/option.rc
-        \\     ~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        \\<cli>: error: missing input filename
-        \\
-        \\<cli>: note: if this argument was intended to be the input filename, then -- should be specified in front of it to exclude it from option parsing
-        \\ ... /some/absolute/path/parsed/as/an/option.rc
-        \\     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-        \\
-    );
 }
 
 test "inferred absolute filepaths" {
@@ -1349,8 +1680,8 @@ test "parse: options" {
         defer options.deinit();
 
         try std.testing.expectEqual(true, options.verbose);
-        try std.testing.expectEqualStrings("foo.rc", options.input_filename);
-        try std.testing.expectEqualStrings("foo.res", options.output_filename);
+        try std.testing.expectEqualStrings("foo.rc", options.input_source.filename);
+        try std.testing.expectEqualStrings("foo.res", options.output_source.filename);
     }
     {
         var options = try testParse(&.{ "/vx", "foo.rc" });
@@ -1358,8 +1689,8 @@ test "parse: options" {
 
         try std.testing.expectEqual(true, options.verbose);
         try std.testing.expectEqual(true, options.ignore_include_env_var);
-        try std.testing.expectEqualStrings("foo.rc", options.input_filename);
-        try std.testing.expectEqualStrings("foo.res", options.output_filename);
+        try std.testing.expectEqualStrings("foo.rc", options.input_source.filename);
+        try std.testing.expectEqualStrings("foo.res", options.output_source.filename);
     }
     {
         var options = try testParse(&.{ "/xv", "foo.rc" });
@@ -1367,8 +1698,8 @@ test "parse: options" {
 
         try std.testing.expectEqual(true, options.verbose);
         try std.testing.expectEqual(true, options.ignore_include_env_var);
-        try std.testing.expectEqualStrings("foo.rc", options.input_filename);
-        try std.testing.expectEqualStrings("foo.res", options.output_filename);
+        try std.testing.expectEqualStrings("foo.rc", options.input_source.filename);
+        try std.testing.expectEqualStrings("foo.res", options.output_source.filename);
     }
     {
         var options = try testParse(&.{ "/xvFObar.res", "foo.rc" });
@@ -1376,8 +1707,8 @@ test "parse: options" {
 
         try std.testing.expectEqual(true, options.verbose);
         try std.testing.expectEqual(true, options.ignore_include_env_var);
-        try std.testing.expectEqualStrings("foo.rc", options.input_filename);
-        try std.testing.expectEqualStrings("bar.res", options.output_filename);
+        try std.testing.expectEqualStrings("foo.rc", options.input_source.filename);
+        try std.testing.expectEqualStrings("bar.res", options.output_source.filename);
     }
 }
 
@@ -1541,24 +1872,208 @@ test "parse: unsupported LCX/LCE-related options" {
     );
 }
 
+test "parse: output filename specified twice" {
+    try testParseError(&.{ "/fo", "foo.res", "foo.rc", "foo.res" },
+        \\<cli>: error: output filename already specified
+        \\ ... foo.res
+        \\     ^~~~~~~
+        \\<cli>: note: output filename previously specified here
+        \\ ... /fo foo.res ...
+        \\     ~~~~^~~~~~~
+        \\
+    );
+}
+
+test "parse: input and output formats" {
+    {
+        try testParseError(&.{ "/:output-format", "rcpp", "foo.res" },
+            \\<cli>: error: input format 'res' cannot be converted to output format 'rcpp'
+            \\
+            \\<cli>: note: the input format was inferred from the input filename
+            \\ ... foo.res
+            \\     ^~~~~~~
+            \\<cli>: note: the output format was specified here
+            \\ ... /:output-format rcpp ...
+            \\     ~~~~~~~~~~~~~~~~^~~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "foo.res", "foo.rcpp" },
+            \\<cli>: error: input format 'res' cannot be converted to output format 'rcpp'
+            \\
+            \\<cli>: note: the input format was inferred from the input filename
+            \\ ... foo.res ...
+            \\     ^~~~~~~
+            \\<cli>: note: the output format was inferred from the output filename
+            \\ ... foo.rcpp
+            \\     ^~~~~~~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "/:input-format", "res", "foo" },
+            \\<cli>: error: input format 'res' cannot be converted to output format 'res'
+            \\
+            \\<cli>: note: the input format was specified here
+            \\ ... /:input-format res ...
+            \\     ~~~~~~~~~~~~~~~^~~
+            \\<cli>: note: the output format was unable to be inferred from the input filename, so the default was used
+            \\ ... foo
+            \\     ^~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "/p", "/:input-format", "res", "foo" },
+            \\<cli>: error: input format 'res' cannot be converted to output format 'res'
+            \\
+            \\<cli>: error: the /p option cannot be used with output format 'res'
+            \\ ... /p ...
+            \\     ^~
+            \\<cli>: note: the input format was specified here
+            \\ ... /:input-format res ...
+            \\     ~~~~~~~~~~~~~~~^~~
+            \\<cli>: note: the output format was unable to be inferred from the input filename, so the default was used
+            \\ ... foo
+            \\     ^~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "/:output-format", "coff", "/p", "foo.rc" },
+            \\<cli>: error: the /p option cannot be used with output format 'coff'
+            \\ ... /p ...
+            \\     ^~
+            \\<cli>: note: the output format was specified here
+            \\ ... /:output-format coff ...
+            \\     ~~~~~~~~~~~~~~~~^~~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "/fo", "foo.res", "/p", "foo.rc" },
+            \\<cli>: error: the /p option cannot be used with output format 'res'
+            \\ ... /p ...
+            \\     ^~
+            \\<cli>: note: the output format was inferred from the output filename
+            \\ ... /fo foo.res ...
+            \\     ~~~~^~~~~~~
+            \\
+        );
+    }
+    {
+        try testParseError(&.{ "/p", "foo.rc", "foo.o" },
+            \\<cli>: error: the /p option cannot be used with output format 'coff'
+            \\ ... /p ...
+            \\     ^~
+            \\<cli>: note: the output format was inferred from the output filename
+            \\ ... foo.o
+            \\     ^~~~~
+            \\
+        );
+    }
+    {
+        var options = try testParse(&.{"foo.rc"});
+        defer options.deinit();
+
+        try std.testing.expectEqual(.rc, options.input_format);
+        try std.testing.expectEqual(.res, options.output_format);
+    }
+    {
+        var options = try testParse(&.{"foo.rcpp"});
+        defer options.deinit();
+
+        try std.testing.expectEqual(.no, options.preprocess);
+        try std.testing.expectEqual(.rcpp, options.input_format);
+        try std.testing.expectEqual(.res, options.output_format);
+    }
+    {
+        var options = try testParse(&.{ "foo.rc", "foo.rcpp" });
+        defer options.deinit();
+
+        try std.testing.expectEqual(.only, options.preprocess);
+        try std.testing.expectEqual(.rc, options.input_format);
+        try std.testing.expectEqual(.rcpp, options.output_format);
+    }
+    {
+        var options = try testParse(&.{ "foo.rc", "foo.obj" });
+        defer options.deinit();
+
+        try std.testing.expectEqual(.rc, options.input_format);
+        try std.testing.expectEqual(.coff, options.output_format);
+    }
+    {
+        var options = try testParse(&.{ "/fo", "foo.o", "foo.rc" });
+        defer options.deinit();
+
+        try std.testing.expectEqual(.rc, options.input_format);
+        try std.testing.expectEqual(.coff, options.output_format);
+    }
+    {
+        var options = try testParse(&.{"foo.res"});
+        defer options.deinit();
+
+        try std.testing.expectEqual(.res, options.input_format);
+        try std.testing.expectEqual(.coff, options.output_format);
+    }
+    {
+        var options = try testParseWarning(&.{ "/:depfile", "foo.json", "foo.rc", "foo.rcpp" },
+            \\<cli>: warning: the /:depfile option was ignored because the output format is 'rcpp'
+            \\ ... /:depfile foo.json ...
+            \\     ~~~~~~~~~~^~~~~~~~
+            \\<cli>: note: the output format was inferred from the output filename
+            \\ ... foo.rcpp
+            \\     ^~~~~~~~
+            \\
+        );
+        defer options.deinit();
+
+        try std.testing.expectEqual(.rc, options.input_format);
+        try std.testing.expectEqual(.rcpp, options.output_format);
+    }
+    {
+        var options = try testParseWarning(&.{ "/:depfile", "foo.json", "foo.res", "foo.o" },
+            \\<cli>: warning: the /:depfile option was ignored because the input format is 'res'
+            \\ ... /:depfile foo.json ...
+            \\     ~~~~~~~~~~^~~~~~~~
+            \\<cli>: note: the input format was inferred from the input filename
+            \\ ... foo.res ...
+            \\     ^~~~~~~
+            \\
+        );
+        defer options.deinit();
+
+        try std.testing.expectEqual(.res, options.input_format);
+        try std.testing.expectEqual(.coff, options.output_format);
+    }
+}
+
 test "maybeAppendRC" {
     var tmp = std.testing.tmpDir(.{});
     defer tmp.cleanup();
 
     var options = try testParse(&.{"foo"});
     defer options.deinit();
-    try std.testing.expectEqualStrings("foo", options.input_filename);
+    try std.testing.expectEqualStrings("foo", options.input_source.filename);
 
     // Create the file so that it's found. In this scenario, .rc should not get
     // appended.
     var file = try tmp.dir.createFile("foo", .{});
     file.close();
     try options.maybeAppendRC(tmp.dir);
-    try std.testing.expectEqualStrings("foo", options.input_filename);
+    try std.testing.expectEqualStrings("foo", options.input_source.filename);
 
-    // Now delete the file and try again. Since the verbatim name is no longer found
-    // and the input filename does not have an extension, .rc should get appended.
+    // Now delete the file and try again. But this time change the input format
+    // to non-rc.
     try tmp.dir.deleteFile("foo");
+    options.input_format = .res;
+    try options.maybeAppendRC(tmp.dir);
+    try std.testing.expectEqualStrings("foo", options.input_source.filename);
+
+    // Finally, reset the input format to rc. Since the verbatim name is no longer found
+    // and the input filename does not have an extension, .rc should get appended.
+    options.input_format = .rc;
     try options.maybeAppendRC(tmp.dir);
-    try std.testing.expectEqualStrings("foo.rc", options.input_filename);
+    try std.testing.expectEqualStrings("foo.rc", options.input_source.filename);
 }
diff --git a/lib/compiler/resinator/cvtres.zig b/lib/compiler/resinator/cvtres.zig
new file mode 100644
index 000000000000..21574f2704d0
--- /dev/null
+++ b/lib/compiler/resinator/cvtres.zig
@@ -0,0 +1,1125 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const res = @import("res.zig");
+const NameOrOrdinal = res.NameOrOrdinal;
+const MemoryFlags = res.MemoryFlags;
+const Language = res.Language;
+const numPaddingBytesNeeded = @import("compile.zig").Compiler.numPaddingBytesNeeded;
+
+pub const Resource = struct {
+    type_value: NameOrOrdinal,
+    name_value: NameOrOrdinal,
+    data_version: u32,
+    memory_flags: MemoryFlags,
+    language: Language,
+    version: u32,
+    characteristics: u32,
+    data: []const u8,
+
+    pub fn deinit(self: Resource, allocator: Allocator) void {
+        self.name_value.deinit(allocator);
+        self.type_value.deinit(allocator);
+        allocator.free(self.data);
+    }
+
+    /// Returns true if all fields match the expected value of the resource at the
+    /// start of all .res files that distinguishes the .res file as 32-bit (as
+    /// opposed to 16-bit).
+    pub fn is32BitPreface(self: Resource) bool {
+        if (self.type_value != .ordinal or self.type_value.ordinal != 0) return false;
+        if (self.name_value != .ordinal or self.name_value.ordinal != 0) return false;
+        if (self.data_version != 0) return false;
+        if (@as(u16, @bitCast(self.memory_flags)) != 0) return false;
+        if (@as(u16, @bitCast(self.language)) != 0) return false;
+        if (self.version != 0) return false;
+        if (self.characteristics != 0) return false;
+        if (self.data.len != 0) return false;
+        return true;
+    }
+
+    pub fn isDlgInclude(resource: Resource) bool {
+        return resource.type_value == .ordinal and resource.type_value.ordinal == @intFromEnum(res.RT.DLGINCLUDE);
+    }
+};
+
+pub const ParsedResources = struct {
+    list: std.ArrayListUnmanaged(Resource) = .empty,
+    allocator: Allocator,
+
+    pub fn init(allocator: Allocator) ParsedResources {
+        return .{ .allocator = allocator };
+    }
+
+    pub fn deinit(self: *ParsedResources) void {
+        for (self.list.items) |*resource| {
+            resource.deinit(self.allocator);
+        }
+        self.list.deinit(self.allocator);
+    }
+};
+
+pub const ParseResOptions = struct {
+    skip_zero_data_resources: bool = true,
+    skip_dlginclude_resources: bool = true,
+    max_size: u64,
+};
+
+/// The returned ParsedResources should be freed by calling its `deinit` function.
+pub fn parseRes(allocator: Allocator, reader: anytype, options: ParseResOptions) !ParsedResources {
+    var resources = ParsedResources.init(allocator);
+    errdefer resources.deinit();
+
+    try parseResInto(&resources, reader, options);
+
+    return resources;
+}
+
+pub fn parseResInto(resources: *ParsedResources, reader: anytype, options: ParseResOptions) !void {
+    const allocator = resources.allocator;
+    var bytes_remaining: u64 = options.max_size;
+    {
+        const first_resource_and_size = try parseResource(allocator, reader, bytes_remaining);
+        defer first_resource_and_size.resource.deinit(allocator);
+        if (!first_resource_and_size.resource.is32BitPreface()) return error.InvalidPreface;
+        bytes_remaining -= first_resource_and_size.total_size;
+    }
+
+    while (bytes_remaining != 0) {
+        const resource_and_size = try parseResource(allocator, reader, bytes_remaining);
+        if (options.skip_zero_data_resources and resource_and_size.resource.data.len == 0) {
+            resource_and_size.resource.deinit(allocator);
+        } else if (options.skip_dlginclude_resources and resource_and_size.resource.isDlgInclude()) {
+            resource_and_size.resource.deinit(allocator);
+        } else {
+            errdefer resource_and_size.resource.deinit(allocator);
+            try resources.list.append(allocator, resource_and_size.resource);
+        }
+        bytes_remaining -= resource_and_size.total_size;
+    }
+}
+
+pub const ResourceAndSize = struct {
+    resource: Resource,
+    total_size: u64,
+};
+
+pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !ResourceAndSize {
+    var header_counting_reader = std.io.countingReader(reader);
+    const header_reader = header_counting_reader.reader();
+    const data_size = try header_reader.readInt(u32, .little);
+    const header_size = try header_reader.readInt(u32, .little);
+    const total_size: u64 = @as(u64, header_size) + data_size;
+    if (total_size > max_size) return error.ImpossibleSize;
+
+    var header_bytes_available = header_size -| 8;
+    var type_reader = std.io.limitedReader(header_reader, header_bytes_available);
+    const type_value = try parseNameOrOrdinal(allocator, type_reader.reader());
+    errdefer type_value.deinit(allocator);
+
+    header_bytes_available -|= @intCast(type_value.byteLen());
+    var name_reader = std.io.limitedReader(header_reader, header_bytes_available);
+    const name_value = try parseNameOrOrdinal(allocator, name_reader.reader());
+    errdefer name_value.deinit(allocator);
+
+    const padding_after_name = numPaddingBytesNeeded(@intCast(header_counting_reader.bytes_read));
+    try header_reader.skipBytes(padding_after_name, .{ .buf_size = 3 });
+
+    std.debug.assert(header_counting_reader.bytes_read % 4 == 0);
+    const data_version = try header_reader.readInt(u32, .little);
+    const memory_flags: MemoryFlags = @bitCast(try header_reader.readInt(u16, .little));
+    const language: Language = @bitCast(try header_reader.readInt(u16, .little));
+    const version = try header_reader.readInt(u32, .little);
+    const characteristics = try header_reader.readInt(u32, .little);
+
+    const header_bytes_read = header_counting_reader.bytes_read;
+    if (header_size != header_bytes_read) return error.HeaderSizeMismatch;
+
+    const data = try allocator.alloc(u8, data_size);
+    errdefer allocator.free(data);
+    try reader.readNoEof(data);
+
+    const padding_after_data = numPaddingBytesNeeded(@intCast(data_size));
+    try reader.skipBytes(padding_after_data, .{ .buf_size = 3 });
+
+    return .{
+        .resource = .{
+            .name_value = name_value,
+            .type_value = type_value,
+            .language = language,
+            .memory_flags = memory_flags,
+            .version = version,
+            .characteristics = characteristics,
+            .data_version = data_version,
+            .data = data,
+        },
+        .total_size = header_size + data.len + padding_after_data,
+    };
+}
+
+pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal {
+    const first_code_unit = try reader.readInt(u16, .little);
+    if (first_code_unit == 0xFFFF) {
+        const ordinal_value = try reader.readInt(u16, .little);
+        return .{ .ordinal = ordinal_value };
+    }
+    var name_buf = try std.ArrayListUnmanaged(u16).initCapacity(allocator, 16);
+    errdefer name_buf.deinit(allocator);
+    var code_unit = first_code_unit;
+    while (code_unit != 0) {
+        try name_buf.append(allocator, std.mem.nativeToLittle(u16, code_unit));
+        code_unit = try reader.readInt(u16, .little);
+    }
+    return .{ .name = try name_buf.toOwnedSliceSentinel(allocator, 0) };
+}
+
+pub const CoffOptions = struct {
+    target: std.coff.MachineType = .X64,
+    /// If true, zeroes will be written to all timestamp fields
+    reproducible: bool = true,
+    /// If true, the MEM_WRITE flag will not be set in the .rsrc section header
+    read_only: bool = false,
+    /// If non-null, a symbol with this name and storage class EXTERNAL will be added to the symbol table.
+    define_external_symbol: ?[]const u8 = null,
+    /// Re-use data offsets for resources with data that is identical.
+    fold_duplicate_data: bool = false,
+};
+
+pub const Diagnostics = union {
+    none: void,
+    /// Contains the index of the second resource in a duplicate resource pair.
+    duplicate_resource: usize,
+    /// Contains the index of the resource that either has data that's too long or
+    /// caused the total data to overflow.
+    overflow_resource: usize,
+};
+
+pub fn writeCoff(allocator: Allocator, writer: anytype, resources: []const Resource, options: CoffOptions, diagnostics: ?*Diagnostics) !void {
+    var resource_tree = ResourceTree.init(allocator, options);
+    defer resource_tree.deinit();
+
+    for (resources, 0..) |*resource, i| {
+        resource_tree.put(resource, i) catch |err| {
+            switch (err) {
+                error.DuplicateResource => {
+                    if (diagnostics) |d_ptr| d_ptr.* = .{ .duplicate_resource = i };
+                },
+                error.ResourceDataTooLong, error.TotalResourceDataTooLong => {
+                    if (diagnostics) |d_ptr| d_ptr.* = .{ .overflow_resource = i };
+                },
+                else => {},
+            }
+            return err;
+        };
+    }
+
+    const lengths = resource_tree.dataLengths();
+    const byte_size_of_relocation = 10;
+    const relocations_len: u32 = @intCast(byte_size_of_relocation * resources.len);
+    const pointer_to_rsrc01_data = @sizeOf(std.coff.CoffHeader) + (@sizeOf(std.coff.SectionHeader) * 2);
+    const pointer_to_relocations = pointer_to_rsrc01_data + lengths.rsrc01;
+    const pointer_to_rsrc02_data = pointer_to_relocations + relocations_len;
+    const pointer_to_symbol_table = pointer_to_rsrc02_data + lengths.rsrc02;
+
+    const timestamp: i64 = if (options.reproducible) 0 else std.time.timestamp();
+    const size_of_optional_header = 0;
+    const machine_type: std.coff.MachineType = options.target;
+    const flags = std.coff.CoffHeaderFlags{
+        .@"32BIT_MACHINE" = 1,
+    };
+    const number_of_symbols = 5 + @as(u32, @intCast(resources.len)) + @intFromBool(options.define_external_symbol != null);
+    const coff_header = std.coff.CoffHeader{
+        .machine = machine_type,
+        .number_of_sections = 2,
+        .time_date_stamp = @as(u32, @truncate(@as(u64, @bitCast(timestamp)))),
+        .pointer_to_symbol_table = pointer_to_symbol_table,
+        .number_of_symbols = number_of_symbols,
+        .size_of_optional_header = size_of_optional_header,
+        .flags = flags,
+    };
+
+    try writer.writeStructEndian(coff_header, .little);
+
+    const rsrc01_header = std.coff.SectionHeader{
+        .name = ".rsrc$01".*,
+        .virtual_size = 0,
+        .virtual_address = 0,
+        .size_of_raw_data = lengths.rsrc01,
+        .pointer_to_raw_data = pointer_to_rsrc01_data,
+        .pointer_to_relocations = if (relocations_len != 0) pointer_to_relocations else 0,
+        .pointer_to_linenumbers = 0,
+        .number_of_relocations = @intCast(resources.len),
+        .number_of_linenumbers = 0,
+        .flags = .{
+            .CNT_INITIALIZED_DATA = 1,
+            .MEM_WRITE = @intFromBool(!options.read_only),
+            .MEM_READ = 1,
+        },
+    };
+    try writer.writeStructEndian(rsrc01_header, .little);
+
+    const rsrc02_header = std.coff.SectionHeader{
+        .name = ".rsrc$02".*,
+        .virtual_size = 0,
+        .virtual_address = 0,
+        .size_of_raw_data = lengths.rsrc02,
+        .pointer_to_raw_data = pointer_to_rsrc02_data,
+        .pointer_to_relocations = 0,
+        .pointer_to_linenumbers = 0,
+        .number_of_relocations = 0,
+        .number_of_linenumbers = 0,
+        .flags = .{
+            .CNT_INITIALIZED_DATA = 1,
+            .MEM_WRITE = @intFromBool(!options.read_only),
+            .MEM_READ = 1,
+        },
+    };
+    try writer.writeStructEndian(rsrc02_header, .little);
+
+    // TODO: test surrogate pairs
+    try resource_tree.sort();
+
+    var string_table = StringTable{};
+    defer string_table.deinit(allocator);
+    const resource_symbols = try resource_tree.writeCoff(
+        allocator,
+        writer,
+        resources,
+        lengths,
+        &string_table,
+    );
+    defer allocator.free(resource_symbols);
+
+    try writeSymbol(writer, .{
+        .name = "@feat.00".*,
+        .value = 0x11,
+        .section_number = .ABSOLUTE,
+        .type = .{
+            .base_type = .NULL,
+            .complex_type = .NULL,
+        },
+        .storage_class = .STATIC,
+        .number_of_aux_symbols = 0,
+    });
+
+    try writeSymbol(writer, .{
+        .name = ".rsrc$01".*,
+        .value = 0,
+        .section_number = @enumFromInt(1),
+        .type = .{
+            .base_type = .NULL,
+            .complex_type = .NULL,
+        },
+        .storage_class = .STATIC,
+        .number_of_aux_symbols = 1,
+    });
+    try writeSectionDefinition(writer, .{
+        .length = lengths.rsrc01,
+        .number_of_relocations = @intCast(resources.len),
+        .number_of_linenumbers = 0,
+        .checksum = 0,
+        .number = 0,
+        .selection = .NONE,
+        .unused = .{0} ** 3,
+    });
+
+    try writeSymbol(writer, .{
+        .name = ".rsrc$02".*,
+        .value = 0,
+        .section_number = @enumFromInt(2),
+        .type = .{
+            .base_type = .NULL,
+            .complex_type = .NULL,
+        },
+        .storage_class = .STATIC,
+        .number_of_aux_symbols = 1,
+    });
+    try writeSectionDefinition(writer, .{
+        .length = lengths.rsrc02,
+        .number_of_relocations = 0,
+        .number_of_linenumbers = 0,
+        .checksum = 0,
+        .number = 0,
+        .selection = .NONE,
+        .unused = .{0} ** 3,
+    });
+
+    for (resource_symbols) |resource_symbol| {
+        try writeSymbol(writer, resource_symbol);
+    }
+
+    if (options.define_external_symbol) |external_symbol_name| {
+        const name_bytes: [8]u8 = name_bytes: {
+            if (external_symbol_name.len > 8) {
+                const string_table_offset: u32 = try string_table.put(allocator, external_symbol_name);
+                var bytes = [_]u8{0} ** 8;
+                std.mem.writeInt(u32, bytes[4..8], string_table_offset, .little);
+                break :name_bytes bytes;
+            } else {
+                var symbol_shortname = [_]u8{0} ** 8;
+                @memcpy(symbol_shortname[0..external_symbol_name.len], external_symbol_name);
+                break :name_bytes symbol_shortname;
+            }
+        };
+
+        try writeSymbol(writer, .{
+            .name = name_bytes,
+            .value = 0,
+            .section_number = .ABSOLUTE,
+            .type = .{
+                .base_type = .NULL,
+                .complex_type = .NULL,
+            },
+            .storage_class = .EXTERNAL,
+            .number_of_aux_symbols = 0,
+        });
+    }
+
+    try writer.writeInt(u32, string_table.totalByteLength(), .little);
+    try writer.writeAll(string_table.bytes.items);
+}
+
+fn writeSymbol(writer: anytype, symbol: std.coff.Symbol) !void {
+    try writer.writeAll(&symbol.name);
+    try writer.writeInt(u32, symbol.value, .little);
+    try writer.writeInt(u16, @intFromEnum(symbol.section_number), .little);
+    try writer.writeInt(u8, @intFromEnum(symbol.type.base_type), .little);
+    try writer.writeInt(u8, @intFromEnum(symbol.type.complex_type), .little);
+    try writer.writeInt(u8, @intFromEnum(symbol.storage_class), .little);
+    try writer.writeInt(u8, symbol.number_of_aux_symbols, .little);
+}
+
+fn writeSectionDefinition(writer: anytype, def: std.coff.SectionDefinition) !void {
+    try writer.writeInt(u32, def.length, .little);
+    try writer.writeInt(u16, def.number_of_relocations, .little);
+    try writer.writeInt(u16, def.number_of_linenumbers, .little);
+    try writer.writeInt(u32, def.checksum, .little);
+    try writer.writeInt(u16, def.number, .little);
+    try writer.writeInt(u8, @intFromEnum(def.selection), .little);
+    try writer.writeAll(&def.unused);
+}
+
+pub const ResourceDirectoryTable = extern struct {
+    characteristics: u32,
+    timestamp: u32,
+    major_version: u16,
+    minor_version: u16,
+    number_of_name_entries: u16,
+    number_of_id_entries: u16,
+};
+
+pub const ResourceDirectoryEntry = extern struct {
+    entry: packed union {
+        name_offset: packed struct(u32) {
+            address: u31,
+            /// This is undocumented in the PE/COFF spec, but the high bit
+            /// is set by cvtres.exe for string addresses
+            to_string: bool = true,
+        },
+        integer_id: u32,
+    },
+    offset: packed struct(u32) {
+        address: u31,
+        to_subdirectory: bool,
+    },
+
+    pub fn writeCoff(self: ResourceDirectoryEntry, writer: anytype) !void {
+        try writer.writeInt(u32, @bitCast(self.entry), .little);
+        try writer.writeInt(u32, @bitCast(self.offset), .little);
+    }
+};
+
+pub const ResourceDataEntry = extern struct {
+    data_rva: u32,
+    size: u32,
+    codepage: u32,
+    reserved: u32 = 0,
+};
+
+/// type -> name -> language
+const ResourceTree = struct {
+    type_to_name_map: std.ArrayHashMapUnmanaged(NameOrOrdinal, NameToLanguageMap, NameOrOrdinalHashContext, true),
+    rsrc_string_table: std.ArrayHashMapUnmanaged(NameOrOrdinal, void, NameOrOrdinalHashContext, true),
+    deduplicated_data: std.StringArrayHashMapUnmanaged(u32),
+    data_offsets: std.ArrayListUnmanaged(u32),
+    rsrc02_len: u32,
+    coff_options: CoffOptions,
+    allocator: Allocator,
+
+    const RelocatableResource = struct {
+        resource: *const Resource,
+        original_index: usize,
+    };
+    const LanguageToResourceMap = std.AutoArrayHashMapUnmanaged(Language, RelocatableResource);
+    const NameToLanguageMap = std.ArrayHashMapUnmanaged(NameOrOrdinal, LanguageToResourceMap, NameOrOrdinalHashContext, true);
+
+    const NameOrOrdinalHashContext = struct {
+        pub fn hash(self: @This(), v: NameOrOrdinal) u32 {
+            _ = self;
+            var hasher = std.hash.Wyhash.init(0);
+            const tag = std.meta.activeTag(v);
+            hasher.update(std.mem.asBytes(&tag));
+            switch (v) {
+                .name => |name| {
+                    hasher.update(std.mem.sliceAsBytes(name));
+                },
+                .ordinal => |*ordinal| {
+                    hasher.update(std.mem.asBytes(ordinal));
+                },
+            }
+            return @truncate(hasher.final());
+        }
+        pub fn eql(self: @This(), a: NameOrOrdinal, b: NameOrOrdinal, b_index: usize) bool {
+            _ = self;
+            _ = b_index;
+            const tag_a = std.meta.activeTag(a);
+            const tag_b = std.meta.activeTag(b);
+            if (tag_a != tag_b) return false;
+
+            return switch (a) {
+                .name => std.mem.eql(u16, a.name, b.name),
+                .ordinal => a.ordinal == b.ordinal,
+            };
+        }
+    };
+
+    pub fn init(allocator: Allocator, coff_options: CoffOptions) ResourceTree {
+        return .{
+            .type_to_name_map = .empty,
+            .rsrc_string_table = .empty,
+            .deduplicated_data = .empty,
+            .data_offsets = .empty,
+            .rsrc02_len = 0,
+            .coff_options = coff_options,
+            .allocator = allocator,
+        };
+    }
+
+    pub fn deinit(self: *ResourceTree) void {
+        for (self.type_to_name_map.values()) |*name_to_lang_map| {
+            for (name_to_lang_map.values()) |*lang_to_resources_map| {
+                lang_to_resources_map.deinit(self.allocator);
+            }
+            name_to_lang_map.deinit(self.allocator);
+        }
+        self.type_to_name_map.deinit(self.allocator);
+        self.rsrc_string_table.deinit(self.allocator);
+        self.deduplicated_data.deinit(self.allocator);
+        self.data_offsets.deinit(self.allocator);
+    }
+
+    pub fn put(self: *ResourceTree, resource: *const Resource, original_index: usize) !void {
+        const name_to_lang_map = blk: {
+            const gop_result = try self.type_to_name_map.getOrPut(self.allocator, resource.type_value);
+            if (!gop_result.found_existing) {
+                gop_result.value_ptr.* = .empty;
+            }
+            break :blk gop_result.value_ptr;
+        };
+        const lang_to_resources_map = blk: {
+            const gop_result = try name_to_lang_map.getOrPut(self.allocator, resource.name_value);
+            if (!gop_result.found_existing) {
+                gop_result.value_ptr.* = .empty;
+            }
+            break :blk gop_result.value_ptr;
+        };
+        {
+            const gop_result = try lang_to_resources_map.getOrPut(self.allocator, resource.language);
+            if (gop_result.found_existing) return error.DuplicateResource;
+            gop_result.value_ptr.* = .{
+                .original_index = original_index,
+                .resource = resource,
+            };
+        }
+
+        // Resize the data_offsets list to accommodate the index, but only if necessary
+        try self.data_offsets.resize(self.allocator, @max(self.data_offsets.items.len, original_index + 1));
+        if (self.coff_options.fold_duplicate_data) {
+            const gop_result = try self.deduplicated_data.getOrPut(self.allocator, resource.data);
+            if (!gop_result.found_existing) {
+                gop_result.value_ptr.* = self.rsrc02_len;
+                try self.incrementRsrc02Len(resource);
+            }
+            self.data_offsets.items[original_index] = gop_result.value_ptr.*;
+        } else {
+            self.data_offsets.items[original_index] = self.rsrc02_len;
+            try self.incrementRsrc02Len(resource);
+        }
+
+        if (resource.type_value == .name and !self.rsrc_string_table.contains(resource.type_value)) {
+            try self.rsrc_string_table.putNoClobber(self.allocator, resource.type_value, {});
+        }
+        if (resource.name_value == .name and !self.rsrc_string_table.contains(resource.name_value)) {
+            try self.rsrc_string_table.putNoClobber(self.allocator, resource.name_value, {});
+        }
+    }
+
+    fn incrementRsrc02Len(self: *ResourceTree, resource: *const Resource) !void {
+        // Note: This @intCast is only safe if we assume that the resource was parsed from a .res file,
+        // since the maximum data length for a resource in the .res file format is maxInt(u32).
+        // TODO: Either codify this properly or use std.math.cast and return an error.
+        const data_len: u32 = @intCast(resource.data.len);
+        const data_len_including_padding: u32 = std.math.cast(u32, std.mem.alignForward(u33, data_len, 8)) orelse {
+            return error.ResourceDataTooLong;
+        };
+        // TODO: Verify that this corresponds to an actual PE/COFF limitation for resource data
+        //       in the final linked binary. The limit may turn out to be shorter than u32 max if both
+        //       the tree data and the resource data lengths together need to fit within a u32,
+        //       or it may be longer in which case we would want to add more .rsrc$NN sections
+        //       to the object file for the data that overflows .rsrc$02.
+        self.rsrc02_len = std.math.add(u32, self.rsrc02_len, data_len_including_padding) catch {
+            return error.TotalResourceDataTooLong;
+        };
+    }
+
+    const Lengths = struct {
+        level1: u32,
+        level2: u32,
+        level3: u32,
+        data_entries: u32,
+        strings: u32,
+        padding: u32,
+
+        rsrc01: u32,
+        rsrc02: u32,
+
+        fn stringsStart(self: Lengths) u32 {
+            return self.rsrc01 - self.strings - self.padding;
+        }
+    };
+
+    pub fn dataLengths(self: *const ResourceTree) Lengths {
+        var lengths: Lengths = .{
+            .level1 = 0,
+            .level2 = 0,
+            .level3 = 0,
+            .data_entries = 0,
+            .strings = 0,
+            .padding = 0,
+            .rsrc01 = undefined,
+            .rsrc02 = self.rsrc02_len,
+        };
+        lengths.level1 += @sizeOf(ResourceDirectoryTable);
+        for (self.type_to_name_map.values()) |name_to_lang_map| {
+            lengths.level1 += @sizeOf(ResourceDirectoryEntry);
+            lengths.level2 += @sizeOf(ResourceDirectoryTable);
+            for (name_to_lang_map.values()) |lang_to_resources_map| {
+                lengths.level2 += @sizeOf(ResourceDirectoryEntry);
+                lengths.level3 += @sizeOf(ResourceDirectoryTable);
+                for (lang_to_resources_map.values()) |_| {
+                    lengths.level3 += @sizeOf(ResourceDirectoryEntry);
+                    lengths.data_entries += @sizeOf(ResourceDataEntry);
+                }
+            }
+        }
+        for (self.rsrc_string_table.keys()) |v| {
+            lengths.strings += @sizeOf(u16); // string length
+            lengths.strings += @intCast(v.name.len * @sizeOf(u16));
+        }
+        lengths.rsrc01 = lengths.level1 + lengths.level2 + lengths.level3 + lengths.data_entries + lengths.strings;
+        lengths.padding = @intCast((4 -% lengths.rsrc01) % 4);
+        lengths.rsrc01 += lengths.padding;
+        return lengths;
+    }
+
+    pub fn sort(self: *ResourceTree) !void {
+        const NameOrOrdinalSortContext = struct {
+            keys: []NameOrOrdinal,
+
+            pub fn lessThan(ctx: @This(), a_index: usize, b_index: usize) bool {
+                const a = ctx.keys[a_index];
+                const b = ctx.keys[b_index];
+                if (std.meta.activeTag(a) != std.meta.activeTag(b)) {
+                    return if (a == .name) true else false;
+                }
+                switch (a) {
+                    .name => {
+                        const n = @min(a.name.len, b.name.len);
+                        for (a.name[0..n], b.name[0..n]) |a_c, b_c| {
+                            switch (std.math.order(std.mem.littleToNative(u16, a_c), std.mem.littleToNative(u16, b_c))) {
+                                .eq => continue,
+                                .lt => return true,
+                                .gt => return false,
+                            }
+                        }
+                        return a.name.len < b.name.len;
+                    },
+                    .ordinal => {
+                        return a.ordinal < b.ordinal;
+                    },
+                }
+            }
+        };
+        self.type_to_name_map.sortUnstable(NameOrOrdinalSortContext{ .keys = self.type_to_name_map.keys() });
+        for (self.type_to_name_map.values()) |*name_to_lang_map| {
+            name_to_lang_map.sortUnstable(NameOrOrdinalSortContext{ .keys = name_to_lang_map.keys() });
+        }
+        const LangSortContext = struct {
+            keys: []Language,
+
+            pub fn lessThan(ctx: @This(), a_index: usize, b_index: usize) bool {
+                return @as(u16, @bitCast(ctx.keys[a_index])) < @as(u16, @bitCast(ctx.keys[b_index]));
+            }
+        };
+        for (self.type_to_name_map.values()) |*name_to_lang_map| {
+            for (name_to_lang_map.values()) |*lang_to_resource_map| {
+                lang_to_resource_map.sortUnstable(LangSortContext{ .keys = lang_to_resource_map.keys() });
+            }
+        }
+    }
+
+    pub fn writeCoff(
+        self: *const ResourceTree,
+        allocator: Allocator,
+        writer: anytype,
+        resources_in_data_order: []const Resource,
+        lengths: Lengths,
+        coff_string_table: *StringTable,
+    ) ![]const std.coff.Symbol {
+        if (self.type_to_name_map.count() == 0) {
+            try writer.writeByteNTimes(0, 16);
+            return &.{};
+        }
+
+        var counting_writer = std.io.countingWriter(writer);
+        const w = counting_writer.writer();
+
+        var level2_list: std.ArrayListUnmanaged(*const NameToLanguageMap) = .empty;
+        defer level2_list.deinit(allocator);
+
+        var level3_list: std.ArrayListUnmanaged(*const LanguageToResourceMap) = .empty;
+        defer level3_list.deinit(allocator);
+
+        var resources_list: std.ArrayListUnmanaged(*const RelocatableResource) = .empty;
+        defer resources_list.deinit(allocator);
+
+        var relocations = Relocations.init(allocator);
+        defer relocations.deinit();
+
+        var string_offsets = try allocator.alloc(u31, self.rsrc_string_table.count());
+        const strings_start = lengths.stringsStart();
+        defer allocator.free(string_offsets);
+        {
+            var string_address: u31 = @intCast(strings_start);
+            for (self.rsrc_string_table.keys(), 0..) |v, i| {
+                string_offsets[i] = string_address;
+                string_address += @sizeOf(u16) + @as(u31, @intCast(v.name.len * @sizeOf(u16)));
+            }
+        }
+
+        const level2_start = lengths.level1;
+        var level2_address = level2_start;
+        {
+            const counts = entryTypeCounts(self.type_to_name_map.keys());
+            const table = ResourceDirectoryTable{
+                .characteristics = 0,
+                .timestamp = 0,
+                .major_version = 0,
+                .minor_version = 0,
+                .number_of_id_entries = counts.ids,
+                .number_of_name_entries = counts.names,
+            };
+            try w.writeStructEndian(table, .little);
+
+            var it = self.type_to_name_map.iterator();
+            while (it.next()) |entry| {
+                const type_value = entry.key_ptr;
+                const dir_entry = ResourceDirectoryEntry{
+                    .entry = switch (type_value.*) {
+                        .name => .{ .name_offset = .{ .address = string_offsets[self.rsrc_string_table.getIndex(type_value.*).?] } },
+                        .ordinal => .{ .integer_id = type_value.ordinal },
+                    },
+                    .offset = .{
+                        .address = @intCast(level2_address),
+                        .to_subdirectory = true,
+                    },
+                };
+                try dir_entry.writeCoff(w);
+                level2_address += @sizeOf(ResourceDirectoryTable) + @as(u32, @intCast(entry.value_ptr.count() * @sizeOf(ResourceDirectoryEntry)));
+
+                const name_to_lang_map = entry.value_ptr;
+                try level2_list.append(allocator, name_to_lang_map);
+            }
+        }
+        std.debug.assert(counting_writer.bytes_written == level2_start);
+
+        const level3_start = level2_start + lengths.level2;
+        var level3_address = level3_start;
+        for (level2_list.items) |name_to_lang_map| {
+            const counts = entryTypeCounts(name_to_lang_map.keys());
+            const table = ResourceDirectoryTable{
+                .characteristics = 0,
+                .timestamp = 0,
+                .major_version = 0,
+                .minor_version = 0,
+                .number_of_id_entries = counts.ids,
+                .number_of_name_entries = counts.names,
+            };
+            try w.writeStructEndian(table, .little);
+
+            var it = name_to_lang_map.iterator();
+            while (it.next()) |entry| {
+                const name_value = entry.key_ptr;
+                const dir_entry = ResourceDirectoryEntry{
+                    .entry = switch (name_value.*) {
+                        .name => .{ .name_offset = .{ .address = string_offsets[self.rsrc_string_table.getIndex(name_value.*).?] } },
+                        .ordinal => .{ .integer_id = name_value.ordinal },
+                    },
+                    .offset = .{
+                        .address = @intCast(level3_address),
+                        .to_subdirectory = true,
+                    },
+                };
+                try dir_entry.writeCoff(w);
+                level3_address += @sizeOf(ResourceDirectoryTable) + @as(u32, @intCast(entry.value_ptr.count() * @sizeOf(ResourceDirectoryEntry)));
+
+                const lang_to_resources_map = entry.value_ptr;
+                try level3_list.append(allocator, lang_to_resources_map);
+            }
+        }
+        std.debug.assert(counting_writer.bytes_written == level3_start);
+
+        var reloc_addresses = try allocator.alloc(u32, resources_in_data_order.len);
+        defer allocator.free(reloc_addresses);
+
+        const data_entries_start = level3_start + lengths.level3;
+        var data_entry_address = data_entries_start;
+        for (level3_list.items) |lang_to_resources_map| {
+            const counts = EntryTypeCounts{
+                .names = 0,
+                .ids = @intCast(lang_to_resources_map.count()),
+            };
+            const table = ResourceDirectoryTable{
+                .characteristics = 0,
+                .timestamp = 0,
+                .major_version = 0,
+                .minor_version = 0,
+                .number_of_id_entries = counts.ids,
+                .number_of_name_entries = counts.names,
+            };
+            try w.writeStructEndian(table, .little);
+
+            var it = lang_to_resources_map.iterator();
+            while (it.next()) |entry| {
+                const lang = entry.key_ptr.*;
+                const dir_entry = ResourceDirectoryEntry{
+                    .entry = .{ .integer_id = lang.asInt() },
+                    .offset = .{
+                        .address = @intCast(data_entry_address),
+                        .to_subdirectory = false,
+                    },
+                };
+
+                const reloc_resource = entry.value_ptr;
+                reloc_addresses[reloc_resource.original_index] = @intCast(data_entry_address);
+
+                try dir_entry.writeCoff(w);
+                data_entry_address += @sizeOf(ResourceDataEntry);
+
+                try resources_list.append(allocator, reloc_resource);
+            }
+        }
+        std.debug.assert(counting_writer.bytes_written == data_entries_start);
+
+        for (resources_list.items, 0..) |reloc_resource, i| {
+            // TODO: This logic works but is convoluted, would be good to clean this up
+            const orig_resource = &resources_in_data_order[reloc_resource.original_index];
+            const address: u32 = reloc_addresses[i];
+            try relocations.add(address, self.data_offsets.items[i]);
+            const data_entry = ResourceDataEntry{
+                .data_rva = 0, // relocation
+                .size = @intCast(orig_resource.data.len),
+                .codepage = 0,
+            };
+            try w.writeStructEndian(data_entry, .little);
+        }
+        std.debug.assert(counting_writer.bytes_written == strings_start);
+
+        for (self.rsrc_string_table.keys()) |v| {
+            const str = v.name;
+            try w.writeInt(u16, @intCast(str.len), .little);
+            try w.writeAll(std.mem.sliceAsBytes(str));
+        }
+
+        try w.writeByteNTimes(0, lengths.padding);
+
+        for (relocations.list.items) |relocation| {
+            try writeRelocation(w, std.coff.Relocation{
+                .virtual_address = relocation.relocation_address,
+                .symbol_table_index = relocation.symbol_index,
+                .type = supported_targets.rvaRelocationTypeIndicator(self.coff_options.target).?,
+            });
+        }
+
+        if (self.coff_options.fold_duplicate_data) {
+            for (self.deduplicated_data.keys()) |data| {
+                const padding_bytes: u4 = @intCast((8 -% data.len) % 8);
+                try w.writeAll(data);
+                try w.writeByteNTimes(0, padding_bytes);
+            }
+        } else {
+            for (resources_in_data_order) |resource| {
+                const padding_bytes: u4 = @intCast((8 -% resource.data.len) % 8);
+                try w.writeAll(resource.data);
+                try w.writeByteNTimes(0, padding_bytes);
+            }
+        }
+
+        var symbols = try allocator.alloc(std.coff.Symbol, resources_list.items.len);
+        errdefer allocator.free(symbols);
+
+        for (relocations.list.items, 0..) |relocation, i| {
+            // cvtres.exe writes the symbol names as $R<data offset as hexadecimal>.
+            //
+            // When the data offset would exceed 6 hex digits in cvtres.exe, it
+            // truncates the value down to 6 hex digits. This is bad behavior, since
+            // e.g. an initial resource with exactly 16 MiB of data and the
+            // resource following it would both have the symbol name $R000000.
+            //
+            // Instead, if the offset would exceed 6 hexadecimal digits,
+            // we put the longer name in the string table.
+            //
+            // Another option would be to adopt llvm-cvtres' behavior
+            // of $R000001, $R000002, etc. rather than using data offset values.
+            var name_buf: [8]u8 = undefined;
+            if (relocation.data_offset > std.math.maxInt(u24)) {
+                const name_slice = try std.fmt.allocPrint(allocator, "$R{X}", .{relocation.data_offset});
+                defer allocator.free(name_slice);
+                const string_table_offset: u32 = try coff_string_table.put(allocator, name_slice);
+                std.mem.writeInt(u32, name_buf[0..4], 0, .little);
+                std.mem.writeInt(u32, name_buf[4..8], string_table_offset, .little);
+            } else {
+                const name_slice = std.fmt.bufPrint(&name_buf, "$R{X:0>6}", .{relocation.data_offset}) catch unreachable;
+                std.debug.assert(name_slice.len == 8);
+            }
+
+            symbols[i] = .{
+                .name = name_buf,
+                .value = relocation.data_offset,
+                .section_number = @enumFromInt(2),
+                .type = .{
+                    .base_type = .NULL,
+                    .complex_type = .NULL,
+                },
+                .storage_class = .STATIC,
+                .number_of_aux_symbols = 0,
+            };
+        }
+
+        return symbols;
+    }
+
+    fn writeRelocation(writer: anytype, relocation: std.coff.Relocation) !void {
+        try writer.writeInt(u32, relocation.virtual_address, .little);
+        try writer.writeInt(u32, relocation.symbol_table_index, .little);
+        try writer.writeInt(u16, relocation.type, .little);
+    }
+
+    const EntryTypeCounts = struct {
+        names: u16,
+        ids: u16,
+    };
+
+    fn entryTypeCounts(s: []const NameOrOrdinal) EntryTypeCounts {
+        var names: u16 = 0;
+        var ordinals: u16 = 0;
+        for (s) |v| {
+            switch (v) {
+                .name => names += 1,
+                .ordinal => ordinals += 1,
+            }
+        }
+        return .{ .names = names, .ids = ordinals };
+    }
+};
+
+const Relocation = struct {
+    symbol_index: u32,
+    data_offset: u32,
+    relocation_address: u32,
+};
+
+const Relocations = struct {
+    allocator: Allocator,
+    list: std.ArrayListUnmanaged(Relocation) = .empty,
+    cur_symbol_index: u32 = 5,
+
+    pub fn init(allocator: Allocator) Relocations {
+        return .{ .allocator = allocator };
+    }
+
+    pub fn deinit(self: *Relocations) void {
+        self.list.deinit(self.allocator);
+    }
+
+    pub fn add(self: *Relocations, relocation_address: u32, data_offset: u32) !void {
+        try self.list.append(self.allocator, .{
+            .symbol_index = self.cur_symbol_index,
+            .data_offset = data_offset,
+            .relocation_address = relocation_address,
+        });
+        self.cur_symbol_index += 1;
+    }
+};
+
+/// Does not do deduplication (only because there's no chance of duplicate strings in this
+/// instance).
+const StringTable = struct {
+    bytes: std.ArrayListUnmanaged(u8) = .empty,
+
+    pub fn deinit(self: *StringTable, allocator: Allocator) void {
+        self.bytes.deinit(allocator);
+    }
+
+    /// Returns the byte offset of the string in the string table
+    pub fn put(self: *StringTable, allocator: Allocator, string: []const u8) !u32 {
+        const null_terminated_len = string.len + 1;
+        const start_offset = self.totalByteLength();
+        if (start_offset + null_terminated_len > std.math.maxInt(u32)) {
+            return error.StringTableOverflow;
+        }
+        try self.bytes.ensureUnusedCapacity(allocator, null_terminated_len);
+        self.bytes.appendSliceAssumeCapacity(string);
+        self.bytes.appendAssumeCapacity(0);
+        return start_offset;
+    }
+
+    /// Returns the total byte count of the string table, including the byte count of the size field
+    pub fn totalByteLength(self: StringTable) u32 {
+        return @intCast(4 + self.bytes.items.len);
+    }
+};
+
+pub const supported_targets = struct {
+    /// Enum containing a mixture of names that come from:
+    /// - Machine Types constants in the PE format spec:
+    ///   https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#machine-types
+    /// - cvtres.exe /machine options
+    /// - Zig/LLVM arch names
+    /// All field names are lowercase regardless of their casing used in the above origins.
+    pub const Arch = enum {
+        // cvtres.exe /machine names
+        x64,
+        x86,
+        /// Note: Following cvtres.exe's lead, this corresponds to ARMNT, not ARM
+        arm,
+        arm64,
+        arm64ec,
+        arm64x,
+        ia64,
+        ebc,
+
+        // PE/COFF MACHINE constant names not covered above
+        amd64,
+        i386,
+        armnt,
+
+        // Zig/LLVM names not already covered above
+        x86_64,
+        aarch64,
+
+        pub fn toCoffMachineType(arch: Arch) std.coff.MachineType {
+            return switch (arch) {
+                .x64, .amd64, .x86_64 => .X64,
+                .x86, .i386 => .I386,
+                .arm, .armnt => .ARMNT,
+                .arm64, .aarch64 => .ARM64,
+                .arm64ec => .ARM64EC,
+                .arm64x => .ARM64X,
+                .ia64 => .IA64,
+                .ebc => .EBC,
+            };
+        }
+
+        pub fn description(arch: Arch) []const u8 {
+            return switch (arch) {
+                .x64, .amd64, .x86_64 => "64-bit X86",
+                .x86, .i386 => "32-bit X86",
+                .arm, .armnt => "ARM Thumb-2 little endian",
+                .arm64, .aarch64 => "ARM64/AArch64 little endian",
+                .arm64ec => "ARM64 \"Emulation Compatible\"",
+                .arm64x => "ARM64 and ARM64EC together",
+                .ia64 => "64-bit Intel Itanium",
+                .ebc => "EFI Byte Code",
+            };
+        }
+
+        pub const ordered_for_display: []const Arch = &.{
+            .x64,
+            .x86_64,
+            .amd64,
+            .x86,
+            .i386,
+            .arm64,
+            .aarch64,
+            .arm,
+            .armnt,
+            .arm64ec,
+            .arm64x,
+            .ia64,
+            .ebc,
+        };
+        comptime {
+            for (@typeInfo(Arch).@"enum".fields) |enum_field| {
+                _ = std.mem.indexOfScalar(Arch, ordered_for_display, @enumFromInt(enum_field.value)) orelse {
+                    @compileError(std.fmt.comptimePrint("'{s}' missing from ordered_for_display", .{enum_field.name}));
+                };
+            }
+        }
+
+        pub const longest_name = blk: {
+            var len = 0;
+            for (@typeInfo(Arch).@"enum".fields) |field| {
+                if (field.name.len > len) len = field.name.len;
+            }
+            break :blk len;
+        };
+
+        pub fn fromStringIgnoreCase(str: []const u8) ?Arch {
+            if (str.len > longest_name) return null;
+            var lower_buf: [longest_name]u8 = undefined;
+            const lower = std.ascii.lowerString(&lower_buf, str);
+            return std.meta.stringToEnum(Arch, lower);
+        }
+
+        test fromStringIgnoreCase {
+            try std.testing.expectEqual(.x64, Arch.fromStringIgnoreCase("x64").?);
+            try std.testing.expectEqual(.x64, Arch.fromStringIgnoreCase("X64").?);
+            try std.testing.expectEqual(.aarch64, Arch.fromStringIgnoreCase("Aarch64").?);
+            try std.testing.expectEqual(null, Arch.fromStringIgnoreCase("armzzz"));
+            try std.testing.expectEqual(null, Arch.fromStringIgnoreCase("long string that is longer than any field"));
+        }
+    };
+
+    // https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#type-indicators
+    pub fn rvaRelocationTypeIndicator(target: std.coff.MachineType) ?u16 {
+        return switch (target) {
+            .X64 => 0x3, // IMAGE_REL_AMD64_ADDR32NB
+            .I386 => 0x7, // IMAGE_REL_I386_DIR32NB
+            .ARMNT => 0x2, // IMAGE_REL_ARM_ADDR32NB
+            .ARM64, .ARM64EC, .ARM64X => 0x2, // IMAGE_REL_ARM64_ADDR32NB
+            .IA64 => 0x10, // IMAGE_REL_IA64_DIR32NB
+            .EBC => 0x1, // This is what cvtres.exe writes for this target, unsure where it comes from
+            else => null,
+        };
+    }
+
+    pub fn isSupported(target: std.coff.MachineType) bool {
+        return rvaRelocationTypeIndicator(target) != null;
+    }
+
+    comptime {
+        // Enforce two things:
+        // 1. Arch enum field names are all lowercase (necessary for how fromStringIgnoreCase is implemented)
+        // 2. All enum fields in Arch have an associated RVA relocation type when converted to a coff.MachineType
+        for (@typeInfo(Arch).@"enum".fields) |enum_field| {
+            const all_lower = all_lower: for (enum_field.name) |c| {
+                if (std.ascii.isUpper(c)) break :all_lower false;
+            } else break :all_lower true;
+            if (!all_lower) @compileError(std.fmt.comptimePrint("Arch field is not all lowercase: {s}", .{enum_field.name}));
+            const coff_machine = @field(Arch, enum_field.name).toCoffMachineType();
+            _ = rvaRelocationTypeIndicator(coff_machine) orelse {
+                @compileError(std.fmt.comptimePrint("No RVA relocation for Arch: {s}", .{enum_field.name}));
+            };
+        }
+    }
+};
diff --git a/lib/compiler/resinator/main.zig b/lib/compiler/resinator/main.zig
index 030101efce70..e4ad61c5226c 100644
--- a/lib/compiler/resinator/main.zig
+++ b/lib/compiler/resinator/main.zig
@@ -7,7 +7,10 @@ const Diagnostics = @import("errors.zig").Diagnostics;
 const cli = @import("cli.zig");
 const preprocess = @import("preprocess.zig");
 const renderErrorMessage = @import("utils.zig").renderErrorMessage;
+const openFileNotDir = @import("utils.zig").openFileNotDir;
+const cvtres = @import("cvtres.zig");
 const hasDisjointCodePage = @import("disjoint_code_page.zig").hasDisjointCodePage;
+const fmtResourceType = @import("res.zig").NameOrOrdinal.fmtResourceType;
 const aro = @import("aro");
 
 pub fn main() !void {
@@ -135,7 +138,10 @@ pub fn main() !void {
 
             try argv.append("arocc"); // dummy command name
             try preprocess.appendAroArgs(aro_arena, &argv, options, include_paths);
-            try argv.append(options.input_filename);
+            try argv.append(switch (options.input_source) {
+                .stdio => "-",
+                .filename => |filename| filename,
+            });
 
             if (options.verbose) {
                 try stdout_writer.writeAll("Preprocessor: arocc (built-in)\n");
@@ -164,120 +170,332 @@ pub fn main() !void {
 
             break :full_input try preprocessed_buf.toOwnedSlice();
         } else {
-            break :full_input std.fs.cwd().readFileAlloc(allocator, options.input_filename, std.math.maxInt(usize)) catch |err| {
-                try error_handler.emitMessage(allocator, .err, "unable to read input file path '{s}': {s}", .{ options.input_filename, @errorName(err) });
-                std.process.exit(1);
-            };
+            switch (options.input_source) {
+                .stdio => |file| {
+                    break :full_input file.readToEndAlloc(allocator, std.math.maxInt(usize)) catch |err| {
+                        try error_handler.emitMessage(allocator, .err, "unable to read input from stdin: {s}", .{@errorName(err)});
+                        std.process.exit(1);
+                    };
+                },
+                .filename => |input_filename| {
+                    break :full_input std.fs.cwd().readFileAlloc(allocator, input_filename, std.math.maxInt(usize)) catch |err| {
+                        try error_handler.emitMessage(allocator, .err, "unable to read input file path '{s}': {s}", .{ input_filename, @errorName(err) });
+                        std.process.exit(1);
+                    };
+                },
+            }
         }
     };
     defer allocator.free(full_input);
 
     if (options.preprocess == .only) {
-        try std.fs.cwd().writeFile(.{ .sub_path = options.output_filename, .data = full_input });
+        switch (options.output_source) {
+            .stdio => |output_file| {
+                try output_file.writeAll(full_input);
+            },
+            .filename => |output_filename| {
+                try std.fs.cwd().writeFile(.{ .sub_path = output_filename, .data = full_input });
+            },
+        }
         return;
     }
 
-    // Note: We still want to run this when no-preprocess is set because:
-    //   1. We want to print accurate line numbers after removing multiline comments
-    //   2. We want to be able to handle an already-preprocessed input with #line commands in it
-    var mapping_results = parseAndRemoveLineCommands(allocator, full_input, full_input, .{ .initial_filename = options.input_filename }) catch |err| switch (err) {
-        error.InvalidLineCommand => {
-            // TODO: Maybe output the invalid line command
-            try error_handler.emitMessage(allocator, .err, "invalid line command in the preprocessed source", .{});
-            if (options.preprocess == .no) {
-                try error_handler.emitMessage(allocator, .note, "line commands must be of the format: #line <num> \"<path>\"", .{});
-            } else {
-                try error_handler.emitMessage(allocator, .note, "this is likely to be a bug, please report it", .{});
+    var resources = resources: {
+        const need_intermediate_res = options.output_format == .coff and options.input_format != .res;
+        var res_stream = if (need_intermediate_res)
+            IoStream{
+                .name = "<in-memory intermediate res>",
+                .intermediate = true,
+                .source = .{ .memory = .empty },
             }
-            std.process.exit(1);
-        },
-        error.LineNumberOverflow => {
-            // TODO: Better error message
-            try error_handler.emitMessage(allocator, .err, "line number count exceeded maximum of {}", .{std.math.maxInt(usize)});
-            std.process.exit(1);
-        },
-        error.OutOfMemory => |e| return e,
-    };
-    defer mapping_results.mappings.deinit(allocator);
+        else if (options.input_format == .res)
+            IoStream.fromIoSource(options.input_source, .input) catch |err| {
+                try error_handler.emitMessage(allocator, .err, "unable to read res file path '{s}': {s}", .{ options.input_source.filename, @errorName(err) });
+                std.process.exit(1);
+            }
+        else
+            IoStream.fromIoSource(options.output_source, .output) catch |err| {
+                try error_handler.emitMessage(allocator, .err, "unable to create output file '{s}': {s}", .{ options.output_source.filename, @errorName(err) });
+                std.process.exit(1);
+            };
+        defer res_stream.deinit(allocator);
+
+        const res_data = res_data: {
+            if (options.input_format != .res) {
+                // Note: We still want to run this when no-preprocess is set because:
+                //   1. We want to print accurate line numbers after removing multiline comments
+                //   2. We want to be able to handle an already-preprocessed input with #line commands in it
+                var mapping_results = parseAndRemoveLineCommands(allocator, full_input, full_input, .{ .initial_filename = options.input_source.filename }) catch |err| switch (err) {
+                    error.InvalidLineCommand => {
+                        // TODO: Maybe output the invalid line command
+                        try error_handler.emitMessage(allocator, .err, "invalid line command in the preprocessed source", .{});
+                        if (options.preprocess == .no) {
+                            try error_handler.emitMessage(allocator, .note, "line commands must be of the format: #line <num> \"<path>\"", .{});
+                        } else {
+                            try error_handler.emitMessage(allocator, .note, "this is likely to be a bug, please report it", .{});
+                        }
+                        std.process.exit(1);
+                    },
+                    error.LineNumberOverflow => {
+                        // TODO: Better error message
+                        try error_handler.emitMessage(allocator, .err, "line number count exceeded maximum of {}", .{std.math.maxInt(usize)});
+                        std.process.exit(1);
+                    },
+                    error.OutOfMemory => |e| return e,
+                };
+                defer mapping_results.mappings.deinit(allocator);
+
+                const default_code_page = options.default_code_page orelse .windows1252;
+                const has_disjoint_code_page = hasDisjointCodePage(mapping_results.result, &mapping_results.mappings, default_code_page);
+
+                const final_input = try removeComments(mapping_results.result, mapping_results.result, &mapping_results.mappings);
+
+                var diagnostics = Diagnostics.init(allocator);
+                defer diagnostics.deinit();
+
+                const res_stream_writer = res_stream.source.writer(allocator);
+                var output_buffered_stream = std.io.bufferedWriter(res_stream_writer);
+
+                compile(allocator, final_input, output_buffered_stream.writer(), .{
+                    .cwd = std.fs.cwd(),
+                    .diagnostics = &diagnostics,
+                    .source_mappings = &mapping_results.mappings,
+                    .dependencies_list = maybe_dependencies_list,
+                    .ignore_include_env_var = options.ignore_include_env_var,
+                    .extra_include_paths = options.extra_include_paths.items,
+                    .system_include_paths = include_paths,
+                    .default_language_id = options.default_language_id,
+                    .default_code_page = default_code_page,
+                    .disjoint_code_page = has_disjoint_code_page,
+                    .verbose = options.verbose,
+                    .null_terminate_string_table_strings = options.null_terminate_string_table_strings,
+                    .max_string_literal_codepoints = options.max_string_literal_codepoints,
+                    .silent_duplicate_control_ids = options.silent_duplicate_control_ids,
+                    .warn_instead_of_error_on_invalid_code_page = options.warn_instead_of_error_on_invalid_code_page,
+                }) catch |err| switch (err) {
+                    error.ParseError, error.CompileError => {
+                        try error_handler.emitDiagnostics(allocator, std.fs.cwd(), final_input, &diagnostics, mapping_results.mappings);
+                        // Delete the output file on error
+                        res_stream.cleanupAfterError();
+                        std.process.exit(1);
+                    },
+                    else => |e| return e,
+                };
 
-    const default_code_page = options.default_code_page orelse .windows1252;
-    const has_disjoint_code_page = hasDisjointCodePage(mapping_results.result, &mapping_results.mappings, default_code_page);
+                try output_buffered_stream.flush();
 
-    const final_input = try removeComments(mapping_results.result, mapping_results.result, &mapping_results.mappings);
+                // print any warnings/notes
+                if (!zig_integration) {
+                    diagnostics.renderToStdErr(std.fs.cwd(), final_input, stderr_config, mapping_results.mappings);
+                }
 
-    var output_file = std.fs.cwd().createFile(options.output_filename, .{}) catch |err| {
-        try error_handler.emitMessage(allocator, .err, "unable to create output file '{s}': {s}", .{ options.output_filename, @errorName(err) });
+                // write the depfile
+                if (options.depfile_path) |depfile_path| {
+                    var depfile = std.fs.cwd().createFile(depfile_path, .{}) catch |err| {
+                        try error_handler.emitMessage(allocator, .err, "unable to create depfile '{s}': {s}", .{ depfile_path, @errorName(err) });
+                        std.process.exit(1);
+                    };
+                    defer depfile.close();
+
+                    const depfile_writer = depfile.writer();
+                    var depfile_buffered_writer = std.io.bufferedWriter(depfile_writer);
+                    switch (options.depfile_fmt) {
+                        .json => {
+                            var write_stream = std.json.writeStream(depfile_buffered_writer.writer(), .{ .whitespace = .indent_2 });
+                            defer write_stream.deinit();
+
+                            try write_stream.beginArray();
+                            for (dependencies_list.items) |dep_path| {
+                                try write_stream.write(dep_path);
+                            }
+                            try write_stream.endArray();
+                        },
+                    }
+                    try depfile_buffered_writer.flush();
+                }
+            }
+
+            if (options.output_format != .coff) return;
+
+            break :res_data res_stream.source.readAll(allocator) catch |err| {
+                try error_handler.emitMessage(allocator, .err, "unable to read res from '{s}': {s}", .{ res_stream.name, @errorName(err) });
+                std.process.exit(1);
+            };
+        };
+        // No need to keep the res_data around after parsing the resources from it
+        defer res_data.deinit(allocator);
+
+        std.debug.assert(options.output_format == .coff);
+
+        // TODO: Maybe use a buffered file reader instead of reading file into memory -> fbs
+        var fbs = std.io.fixedBufferStream(res_data.bytes);
+        break :resources cvtres.parseRes(allocator, fbs.reader(), .{ .max_size = res_data.bytes.len }) catch |err| {
+            // TODO: Better errors
+            try error_handler.emitMessage(allocator, .err, "unable to parse res from '{s}': {s}", .{ res_stream.name, @errorName(err) });
+            std.process.exit(1);
+        };
+    };
+    defer resources.deinit();
+
+    var coff_stream = IoStream.fromIoSource(options.output_source, .output) catch |err| {
+        try error_handler.emitMessage(allocator, .err, "unable to create output file '{s}': {s}", .{ options.output_source.filename, @errorName(err) });
         std.process.exit(1);
     };
-    var output_file_closed = false;
-    defer if (!output_file_closed) output_file.close();
-
-    var diagnostics = Diagnostics.init(allocator);
-    defer diagnostics.deinit();
-
-    var output_buffered_stream = std.io.bufferedWriter(output_file.writer());
-
-    compile(allocator, final_input, output_buffered_stream.writer(), .{
-        .cwd = std.fs.cwd(),
-        .diagnostics = &diagnostics,
-        .source_mappings = &mapping_results.mappings,
-        .dependencies_list = maybe_dependencies_list,
-        .ignore_include_env_var = options.ignore_include_env_var,
-        .extra_include_paths = options.extra_include_paths.items,
-        .system_include_paths = include_paths,
-        .default_language_id = options.default_language_id,
-        .default_code_page = default_code_page,
-        .disjoint_code_page = has_disjoint_code_page,
-        .verbose = options.verbose,
-        .null_terminate_string_table_strings = options.null_terminate_string_table_strings,
-        .max_string_literal_codepoints = options.max_string_literal_codepoints,
-        .silent_duplicate_control_ids = options.silent_duplicate_control_ids,
-        .warn_instead_of_error_on_invalid_code_page = options.warn_instead_of_error_on_invalid_code_page,
-    }) catch |err| switch (err) {
-        error.ParseError, error.CompileError => {
-            try error_handler.emitDiagnostics(allocator, std.fs.cwd(), final_input, &diagnostics, mapping_results.mappings);
-            // Delete the output file on error
-            output_file.close();
-            output_file_closed = true;
-            // Failing to delete is not really a big deal, so swallow any errors
-            std.fs.cwd().deleteFile(options.output_filename) catch {};
-            std.process.exit(1);
-        },
-        else => |e| return e,
+    defer coff_stream.deinit(allocator);
+
+    var coff_output_buffered_stream = std.io.bufferedWriter(coff_stream.source.writer(allocator));
+
+    var cvtres_diagnostics: cvtres.Diagnostics = .{ .none = {} };
+    cvtres.writeCoff(allocator, coff_output_buffered_stream.writer(), resources.list.items, options.coff_options, &cvtres_diagnostics) catch |err| {
+        switch (err) {
+            error.DuplicateResource => {
+                const duplicate_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
+                try error_handler.emitMessage(allocator, .err, "duplicate resource [id: {}, type: {}, language: {}]", .{
+                    duplicate_resource.name_value,
+                    fmtResourceType(duplicate_resource.type_value),
+                    duplicate_resource.language,
+                });
+            },
+            error.ResourceDataTooLong => {
+                const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
+                try error_handler.emitMessage(allocator, .err, "resource has a data length that is too large to be written into a coff section", .{});
+                try error_handler.emitMessage(allocator, .note, "the resource with the invalid size is [id: {}, type: {}, language: {}]", .{
+                    overflow_resource.name_value,
+                    fmtResourceType(overflow_resource.type_value),
+                    overflow_resource.language,
+                });
+            },
+            error.TotalResourceDataTooLong => {
+                const overflow_resource = resources.list.items[cvtres_diagnostics.duplicate_resource];
+                try error_handler.emitMessage(allocator, .err, "total resource data exceeds the maximum of the coff 'size of raw data' field", .{});
+                try error_handler.emitMessage(allocator, .note, "size overflow occurred when attempting to write this resource: [id: {}, type: {}, language: {}]", .{
+                    overflow_resource.name_value,
+                    fmtResourceType(overflow_resource.type_value),
+                    overflow_resource.language,
+                });
+            },
+            else => {
+                try error_handler.emitMessage(allocator, .err, "unable to write coff output file '{s}': {s}", .{ coff_stream.name, @errorName(err) });
+            },
+        }
+        // Delete the output file on error
+        coff_stream.cleanupAfterError();
+        std.process.exit(1);
     };
 
-    try output_buffered_stream.flush();
+    try coff_output_buffered_stream.flush();
+}
 
-    // print any warnings/notes
-    if (!zig_integration) {
-        diagnostics.renderToStdErr(std.fs.cwd(), final_input, stderr_config, mapping_results.mappings);
-    }
+const IoStream = struct {
+    name: []const u8,
+    intermediate: bool,
+    source: Source,
 
-    // write the depfile
-    if (options.depfile_path) |depfile_path| {
-        var depfile = std.fs.cwd().createFile(depfile_path, .{}) catch |err| {
-            try error_handler.emitMessage(allocator, .err, "unable to create depfile '{s}': {s}", .{ depfile_path, @errorName(err) });
-            std.process.exit(1);
+    pub const IoDirection = enum { input, output };
+
+    pub fn fromIoSource(source: cli.Options.IoSource, io: IoDirection) !IoStream {
+        return .{
+            .name = switch (source) {
+                .filename => |filename| filename,
+                .stdio => switch (io) {
+                    .input => "<stdin>",
+                    .output => "<stdout>",
+                },
+            },
+            .intermediate = false,
+            .source = try Source.fromIoSource(source, io),
         };
-        defer depfile.close();
-
-        const depfile_writer = depfile.writer();
-        var depfile_buffered_writer = std.io.bufferedWriter(depfile_writer);
-        switch (options.depfile_fmt) {
-            .json => {
-                var write_stream = std.json.writeStream(depfile_buffered_writer.writer(), .{ .whitespace = .indent_2 });
-                defer write_stream.deinit();
-
-                try write_stream.beginArray();
-                for (dependencies_list.items) |dep_path| {
-                    try write_stream.write(dep_path);
-                }
-                try write_stream.endArray();
+    }
+
+    pub fn deinit(self: *IoStream, allocator: std.mem.Allocator) void {
+        self.source.deinit(allocator);
+    }
+
+    pub fn cleanupAfterError(self: *IoStream) void {
+        switch (self.source) {
+            .file => |file| {
+                // Delete the output file on error
+                file.close();
+                // Failing to delete is not really a big deal, so swallow any errors
+                std.fs.cwd().deleteFile(self.name) catch {};
             },
+            .stdio, .memory, .closed => return,
         }
-        try depfile_buffered_writer.flush();
     }
-}
+
+    pub const Source = union(enum) {
+        file: std.fs.File,
+        stdio: std.fs.File,
+        memory: std.ArrayListUnmanaged(u8),
+        /// The source has been closed and any usage of the Source in this state is illegal (except deinit).
+        closed: void,
+
+        pub fn fromIoSource(source: cli.Options.IoSource, io: IoDirection) !Source {
+            switch (source) {
+                .filename => |filename| return .{
+                    .file = switch (io) {
+                        .input => try openFileNotDir(std.fs.cwd(), filename, .{}),
+                        .output => try std.fs.cwd().createFile(filename, .{}),
+                    },
+                },
+                .stdio => |file| return .{ .stdio = file },
+            }
+        }
+
+        pub fn deinit(self: *Source, allocator: std.mem.Allocator) void {
+            switch (self.*) {
+                .file => |file| file.close(),
+                .stdio => {},
+                .memory => |*list| list.deinit(allocator),
+                .closed => {},
+            }
+        }
+
+        pub const Data = struct {
+            bytes: []const u8,
+            needs_free: bool,
+
+            pub fn deinit(self: Data, allocator: std.mem.Allocator) void {
+                if (self.needs_free) {
+                    allocator.free(self.bytes);
+                }
+            }
+        };
+
+        pub fn readAll(self: Source, allocator: std.mem.Allocator) !Data {
+            return switch (self) {
+                inline .file, .stdio => |file| .{
+                    .bytes = try file.readToEndAlloc(allocator, std.math.maxInt(usize)),
+                    .needs_free = true,
+                },
+                .memory => |list| .{ .bytes = list.items, .needs_free = false },
+                .closed => unreachable,
+            };
+        }
+
+        pub const WriterContext = struct {
+            self: *Source,
+            allocator: std.mem.Allocator,
+        };
+        pub const WriteError = std.mem.Allocator.Error || std.fs.File.WriteError;
+        pub const Writer = std.io.Writer(WriterContext, WriteError, write);
+
+        pub fn write(ctx: WriterContext, bytes: []const u8) WriteError!usize {
+            switch (ctx.self.*) {
+                inline .file, .stdio => |file| return file.write(bytes),
+                .memory => |*list| {
+                    try list.appendSlice(ctx.allocator, bytes);
+                    return bytes.len;
+                },
+                .closed => unreachable,
+            }
+        }
+
+        pub fn writer(self: *Source, allocator: std.mem.Allocator) Writer {
+            return .{ .context = .{ .self = self, .allocator = allocator } };
+        }
+    };
+};
 
 fn getIncludePaths(arena: std.mem.Allocator, auto_includes_option: cli.Options.AutoIncludes, zig_lib_dir: []const u8) ![]const []const u8 {
     var includes = auto_includes_option;