diff --git a/CommandLine/CommandLine.swift b/CommandLine/CommandLine.swift
index 8b8bfb1..3742bf3 100644
--- a/CommandLine/CommandLine.swift
+++ b/CommandLine/CommandLine.swift
@@ -31,7 +31,6 @@
 
 import Foundation
 import SwiftDraw
-import SwiftDrawDOM
 
 extension SwiftDraw.CommandLine {
     
@@ -39,36 +38,38 @@ extension SwiftDraw.CommandLine {
                     baseDirectory: URL = .currentDirectory) -> ExitCode {
         
         guard let config = try? parseConfiguration(from: args, baseDirectory: baseDirectory) else {
-            print("Invalid Syntax.", to: &.standardError)
+            Log.error("Invalid Syntax.")
             printHelp()
             return .error
         }
 
+        Log.handler = Log.standardStreams(minimumLevel: config.logLevel)
+
         let data: Data
         do {
             data = try processImage(with: config)
         } catch Error.fileNotFound {
-            print("Failure: File does not exist.", to: &.standardError)
+            Log.error("Failure: File does not exist.")
             return .error
         } catch {
-            print("Failure:", error.localizedDescription, to: &.standardError)
+            Log.error("Failure: \(error.localizedDescription)")
             printHelp()
             return .error
         }
 
         do {
             try data.write(to: config.output)
-            print("Created: \(config.output.path)")
+            Log.info("Created: \(config.output.path)")
         } catch _ {
-            print("Failure: \(config.output.path)", to: &.standardError)
+            Log.error("Failure: \(config.output.path)")
         }
-        
+
         return .ok
     }
-    
+
     static func printHelp() {
-        print("")
-        print("""
+        Log.info("""
+
 swiftdraw, version 0.29.0
 copyright (c) 2026 Simon Whitty
 
@@ -83,6 +84,7 @@ Options:
  --insets      crop inset of output image: top,left,bottom,right
  --precision   maximum number of decimal places
  --output      optional path of output file
+ --quiet       suppress warnings and progress, reporting failures only
 
  --hide-unsupported-filters   hide elements with unsupported filters.
 
diff --git a/DOM/Sources/LogSink.swift b/DOM/Sources/LogSink.swift
new file mode 100644
index 0000000..f385f80
--- /dev/null
+++ b/DOM/Sources/LogSink.swift
@@ -0,0 +1,120 @@
+//
+//  LogSink.swift
+//  SwiftDraw
+//
+//  Created by Simon Whitty on 26/8/26.
+//  Copyright 2026 Simon Whitty
+//
+//  Distributed under the permissive zlib license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/SwiftDraw
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//  claim that you wrote the original software. If you use this software
+//  in a product, an acknowledgment in the product documentation would be
+//  appreciated but is not required.
+//
+//  2. Altered source versions must be plainly marked as such, and must not be
+//  misrepresented as being the original software.
+//
+//  3. This notice may not be removed or altered from any source distribution.
+//
+
+import Foundation
+
+/// Destination for the diagnostic messages emitted while parsing and rendering.
+///
+/// Messages are written to the standard streams by default, matching the output
+/// of previous versions. `SwiftDraw.Log` is the public facade of this sink.
+package enum LogSink {
+
+    package enum Level: Int, Comparable, Hashable, CaseIterable, Sendable {
+        case info
+        case warning
+        case error
+
+        package static func < (lhs: Self, rhs: Self) -> Bool {
+            lhs.rawValue < rhs.rawValue
+        }
+    }
+
+    package typealias Handler = @Sendable (Level, String) -> Void
+
+    /// Receives every message emitted while parsing and rendering.
+    ///
+    /// Defaults to `standardStreams()`. Assign once during startup; the property
+    /// is safe to access from multiple threads but messages emitted while it is
+    /// being replaced may reach either handler.
+    package static var handler: Handler {
+        get {
+            lock.lock()
+            defer { lock.unlock() }
+            return _handler
+        }
+        set {
+            lock.lock()
+            defer { lock.unlock() }
+            _handler = newValue
+        }
+    }
+
+    /// Writes `info` messages to standard output and everything else to standard error.
+    /// - Parameter minimumLevel: messages below this level are discarded.
+    package static func standardStreams(minimumLevel: Level = .info) -> Handler {
+        makeHandler(
+            minimumLevel: minimumLevel,
+            standardOutput: { print($0) },
+            standardError: { print($0, to: &.standardError) }
+        )
+    }
+
+    package static func makeHandler(
+        minimumLevel: Level,
+        standardOutput: @escaping @Sendable (String) -> Void,
+        standardError: @escaping @Sendable (String) -> Void
+    ) -> Handler {
+        { level, message in
+            guard level >= minimumLevel else { return }
+            switch level {
+            case .info:
+                standardOutput(message)
+            case .warning:
+                standardError("Warning: \(message)")
+            case .error:
+                standardError(message)
+            }
+        }
+    }
+
+    private nonisolated(unsafe) static var _handler: Handler = standardStreams()
+    private static let lock = NSLock()
+}
+
+package extension LogSink {
+
+    /// Emits a message that forms part of the expected output, such as the
+    /// alignment insets reported by the SF Symbol renderer.
+    static func info(_ message: String) {
+        handler(.info, message)
+    }
+
+    /// Emits a message about content that was rendered in a degraded way.
+    /// The `Warning:` prefix is applied by the handler.
+    static func warning(_ message: String) {
+        handler(.warning, message)
+    }
+
+    /// Emits a message about content that could not be parsed or encoded.
+    static func error(_ message: String) {
+        handler(.error, message)
+    }
+}
diff --git a/DOM/Sources/Parser.XML.Element.swift b/DOM/Sources/Parser.XML.Element.swift
index 092a967..99900cb 100644
--- a/DOM/Sources/Parser.XML.Element.swift
+++ b/DOM/Sources/Parser.XML.Element.swift
@@ -289,27 +289,31 @@ extension XMLParser {
     }
 
     package static func logParsingError(for error: any Swift.Error, filename: String?, parsing element: XML.Element? = nil) {
+        LogSink.error(makeParsingErrorMessage(for: error, filename: filename, parsing: element))
+    }
+
+    package static func makeParsingErrorMessage(for error: any Swift.Error, filename: String?, parsing element: XML.Element? = nil) -> String {
         let elementName = element.map { "<\($0.name)>" } ?? ""
         let filename = filename ?? ""
         switch error {
         case let XMLParser.Error.invalidDocument(error, element, line, column):
             let element = element.map { "<\($0)>" } ?? ""
             if let error = error {
-                print("[parsing error]", filename, element, "line:", line, "column:", column, "error:", error, to: &.standardError)
+                return "[parsing error] \(filename) \(element) line: \(line) column: \(column) error: \(error)"
             } else {
-                print("[parsing error]", filename, element, "line:", line, "column:", column, to: &.standardError)
+                return "[parsing error] \(filename) \(element) line: \(line) column: \(column)"
             }
         case let XMLParser.Error.invalidElement(name, error, line, column):
             if let line = line {
-                print("[parsing error]", filename, "<\(name)>", "line:", line, "column:", column ?? -1, "error:", error, to: &.standardError)
+                return "[parsing error] \(filename) <\(name)> line: \(line) column: \(column ?? -1) error: \(error)"
             } else {
-                print("[parsing error]", filename, "<\(name)>", "error:", error, to: &.standardError)
+                return "[parsing error] \(filename) <\(name)> error: \(error)"
             }
         default:
             if let location = element?.parsedLocation {
-                print("[parsing error]", filename, elementName, "line:", location.line, "column:", location.column, "error:", error, to: &.standardError)
+                return "[parsing error] \(filename) \(elementName) line: \(location.line) column: \(location.column) error: \(error)"
             } else {
-                print("[parsing error]", filename, elementName, "error:", error, to: &.standardError)
+                return "[parsing error] \(filename) \(elementName) error: \(error)"
             }
         }
     }
diff --git a/DOM/Tests/LogSinkTests.swift b/DOM/Tests/LogSinkTests.swift
new file mode 100644
index 0000000..a73c1d8
--- /dev/null
+++ b/DOM/Tests/LogSinkTests.swift
@@ -0,0 +1,195 @@
+//
+//  LogSinkTests.swift
+//  SwiftDraw
+//
+//  Created by Simon Whitty on 26/8/26.
+//  Copyright 2026 Simon Whitty
+//
+//  Distributed under the permissive zlib license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/SwiftDraw
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//  claim that you wrote the original software. If you use this software
+//  in a product, an acknowledgment in the product documentation would be
+//  appreciated but is not required.
+//
+//  2. Altered source versions must be plainly marked as such, and must not be
+//  misrepresented as being the original software.
+//
+//  3. This notice may not be removed or altered from any source distribution.
+//
+
+import Foundation
+import Testing
+@testable import SwiftDrawDOM
+
+struct LogSinkTests {
+
+    @Test
+    func levelsAreOrderedBySeverity() {
+        #expect(LogSink.Level.info < LogSink.Level.warning)
+        #expect(LogSink.Level.warning < LogSink.Level.error)
+        #expect(LogSink.Level.allCases == [.info, .warning, .error])
+    }
+
+    @Test
+    func infoIsWrittenToStandardOutput() {
+        let streams = Streams()
+
+        streams.makeHandler()(.info, "Alignment: --insets 1,2,3,4")
+
+        #expect(streams.lines == ["out: Alignment: --insets 1,2,3,4"])
+    }
+
+    @Test
+    func warningIsPrefixedAndWrittenToStandardError() {
+        let streams = Streams()
+
+        streams.makeHandler()(.warning, "PDF does not support transparency masks")
+
+        #expect(streams.lines == ["err: Warning: PDF does not support transparency masks"])
+    }
+
+    @Test
+    func errorIsWrittenToStandardErrorWithoutPrefix() {
+        let streams = Streams()
+
+        streams.makeHandler()(.error, "[parsing error] file.svg <style> error: invalid")
+
+        #expect(streams.lines == ["err: [parsing error] file.svg <style> error: invalid"])
+    }
+
+    @Test
+    func minimumLevelInfoKeepsEveryMessage() {
+        let streams = Streams()
+        let handler = streams.makeHandler(minimumLevel: .info)
+
+        for level in LogSink.Level.allCases {
+            handler(level, "message")
+        }
+
+        #expect(streams.lines == [
+            "out: message",
+            "err: Warning: message",
+            "err: message"
+        ])
+    }
+
+    @Test
+    func minimumLevelWarningDiscardsInfo() {
+        let streams = Streams()
+        let handler = streams.makeHandler(minimumLevel: .warning)
+
+        for level in LogSink.Level.allCases {
+            handler(level, "message")
+        }
+
+        #expect(streams.lines == [
+            "err: Warning: message",
+            "err: message"
+        ])
+    }
+
+    @Test
+    func minimumLevelErrorDiscardsInfoAndWarning() {
+        let streams = Streams()
+        let handler = streams.makeHandler(minimumLevel: .error)
+
+        for level in LogSink.Level.allCases {
+            handler(level, "message")
+        }
+
+        #expect(streams.lines == ["err: message"])
+    }
+}
+
+struct ParsingErrorMessageTests {
+
+    @Test
+    func invalidElementWithLocation() {
+        let message = XMLParser.makeParsingErrorMessage(
+            for: XMLParser.Error.invalidElement(
+                name: "rect",
+                error: DescribedError(),
+                line: 3,
+                column: 7
+            ),
+            filename: "sample.svg"
+        )
+
+        #expect(message == "[parsing error] sample.svg <rect> line: 3 column: 7 error: missing width")
+    }
+
+    @Test
+    func invalidElementWithoutLocation() {
+        let message = XMLParser.makeParsingErrorMessage(
+            for: XMLParser.Error.invalidElement(
+                name: "rect",
+                error: XMLParser.Error.invalid,
+                line: nil,
+                column: nil
+            ),
+            filename: "sample.svg"
+        )
+
+        #expect(message == "[parsing error] sample.svg <rect> error: invalid")
+    }
+
+    @Test
+    func invalidDocument() {
+        let message = XMLParser.makeParsingErrorMessage(
+            for: XMLParser.Error.invalidDocument(
+                error: nil,
+                element: "svg",
+                line: 1,
+                column: 2
+            ),
+            filename: "sample.svg"
+        )
+
+        #expect(message == "[parsing error] sample.svg <svg> line: 1 column: 2")
+    }
+}
+
+/// Nested errors are interpolated into the message, so the expected text must not
+/// depend on how a given platform reflects an enum with associated values.
+private struct DescribedError: Error, CustomStringConvertible {
+    var description: String { "missing width" }
+}
+
+private final class Streams: @unchecked Sendable {
+
+    var lines: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return stored
+    }
+
+    func makeHandler(minimumLevel: LogSink.Level = .info) -> LogSink.Handler {
+        LogSink.makeHandler(
+            minimumLevel: minimumLevel,
+            standardOutput: { [self] in append("out: \($0)") },
+            standardError: { [self] in append("err: \($0)") }
+        )
+    }
+
+    @Sendable
+    func append(_ line: String) {
+        lock.lock()
+        defer { lock.unlock() }
+        stored.append(line)
+    }
+
+    private let lock = NSLock()
+    private var stored = [String]()
+}
diff --git a/README.md b/README.md
index 2cbd6c0..48930cc 100644
--- a/README.md
+++ b/README.md
@@ -134,6 +134,30 @@ import SwiftDraw
 let image = NSImage(svgNamed: "sample.svg")
 ```
 
+### Diagnostics
+
+Unsupported content and parsing errors are reported while an SVG is parsed and rendered. These messages are written to the standard streams by default; `Log.handler` routes them somewhere else instead:
+
+```swift
+import SwiftDraw
+
+Log.handler = { level, message in
+    switch level {
+    case .info:    logger.info("\(message)")
+    case .warning: logger.warning("\(message)")
+    case .error:   logger.error("\(message)")
+    }
+}
+```
+
+Or silences them entirely:
+
+```swift
+Log.handler = Log.silent
+```
+
+Assign the handler once during startup, before any SVG is loaded. The command line tool exposes the same control with `--quiet`, which reports failures only.
+
 ## Command line tool
 
 The command line tool converts SVGs to other formats: PNG, JPEG, SFSymbol and Swift source code.
@@ -152,6 +176,7 @@ Options:
  --insets      crop inset of output image: top,left,bottom,right
  --precision   maximum number of decimal places
  --output      optional path of output file
+ --quiet       suppress warnings and progress, reporting failures only
 
  --hide-unsupported-filters   hide elements with unsupported filters.
 
diff --git a/SwiftDraw/Sources/CommandLine/CommandLine.Arguments.swift b/SwiftDraw/Sources/CommandLine/CommandLine.Arguments.swift
index 674b98d..ed19909 100644
--- a/SwiftDraw/Sources/CommandLine/CommandLine.Arguments.swift
+++ b/SwiftDraw/Sources/CommandLine/CommandLine.Arguments.swift
@@ -49,10 +49,11 @@ extension CommandLine {
         case blackStrokeWidth
         case hideUnsupportedFilters
         case legacy
+        case quiet
 
         var hasValue: Bool {
             switch self {
-            case .hideUnsupportedFilters, .legacy:
+            case .hideUnsupportedFilters, .legacy, .quiet:
                 return false
             default:
                 return true
diff --git a/SwiftDraw/Sources/CommandLine/CommandLine.Configuration.swift b/SwiftDraw/Sources/CommandLine/CommandLine.Configuration.swift
index 13ec977..c1f8e4e 100644
--- a/SwiftDraw/Sources/CommandLine/CommandLine.Configuration.swift
+++ b/SwiftDraw/Sources/CommandLine/CommandLine.Configuration.swift
@@ -52,6 +52,7 @@ extension CommandLine {
         public var isLegacyInsetsEnabled: Bool
         public var ultralightStrokeScale: SFSymbolRenderer.StrokeWidthScale?
         public var blackStrokeScale: SFSymbolRenderer.StrokeWidthScale?
+        public var logLevel: Log.Level = .info
     }
 
     public enum Format: String {
@@ -144,7 +145,8 @@ extension CommandLine {
             symbolSize: symbolSize,
             isLegacyInsetsEnabled: modifiers.keys.contains(.legacy),
             ultralightStrokeScale: ultralightStroke,
-            blackStrokeScale: blackStroke
+            blackStrokeScale: blackStroke,
+            logLevel: modifiers.keys.contains(.quiet) ? .error : .info
         )
     }
 
diff --git a/SwiftDraw/Sources/Formatter/XML.Formatter.SVG.swift b/SwiftDraw/Sources/Formatter/XML.Formatter.SVG.swift
index 3dbe534..945380b 100644
--- a/SwiftDraw/Sources/Formatter/XML.Formatter.SVG.swift
+++ b/SwiftDraw/Sources/Formatter/XML.Formatter.SVG.swift
@@ -172,9 +172,9 @@ extension XML.Formatter {
                 do {
                     elements.append(try makeElement(from: graphic))
                 } catch Error.unsupportedGraphicsElement {
-                    print("Warning:", elementName, "has no encoder, ignoring element.", to: &.standardError)
+                    LogSink.warning("\(elementName) has no encoder, ignoring element.")
                 } catch {
-                    print("[encoding error]", elementName, "error:", error, to: &.standardError)
+                    LogSink.error("[encoding error] \(elementName) error: \(error)")
                     throw error
                 }
             }
diff --git a/SwiftDraw/Sources/LayerTree/LayerTree.CommandGenerator.swift b/SwiftDraw/Sources/LayerTree/LayerTree.CommandGenerator.swift
index 79b3315..0c61aa9 100644
--- a/SwiftDraw/Sources/LayerTree/LayerTree.CommandGenerator.swift
+++ b/SwiftDraw/Sources/LayerTree/LayerTree.CommandGenerator.swift
@@ -570,19 +570,19 @@ extension LayerTree.CommandGenerator {
         #endif
         }
 
-        print("Warning:", name, "is not supported. Elements with this filter can be hidden with \(hint)", to: &.standardError)
+        LogSink.warning("\(name) is not supported. Elements with this filter can be hidden with \(hint)")
         hasLoggedFilterWarning = true
     }
 
     func logUnsupportedGradient() {
         guard !hasLoggedGradientWarning else { return }
-        print("Warning:", "PDF does not support gradients with stop-opacity", to: &.standardError)
+        LogSink.warning("PDF does not support gradients with stop-opacity")
         hasLoggedGradientWarning = true
     }
 
     func logUnsupportedMask() {
         guard !hasLoggedMaskWarning else { return }
-        print("Warning:", "PDF does not support transparency masks", to: &.standardError)
+        LogSink.warning("PDF does not support transparency masks")
         hasLoggedMaskWarning = true
     }
 }
diff --git a/SwiftDraw/Sources/Log.swift b/SwiftDraw/Sources/Log.swift
new file mode 100644
index 0000000..e7c9552
--- /dev/null
+++ b/SwiftDraw/Sources/Log.swift
@@ -0,0 +1,128 @@
+//
+//  Log.swift
+//  SwiftDraw
+//
+//  Created by Simon Whitty on 26/8/26.
+//  Copyright 2026 Simon Whitty
+//
+//  Distributed under the permissive zlib license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/SwiftDraw
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//  claim that you wrote the original software. If you use this software
+//  in a product, an acknowledgment in the product documentation would be
+//  appreciated but is not required.
+//
+//  2. Altered source versions must be plainly marked as such, and must not be
+//  misrepresented as being the original software.
+//
+//  3. This notice may not be removed or altered from any source distribution.
+//
+
+import SwiftDrawDOM
+
+/// Destination for the diagnostic messages emitted while parsing and rendering.
+///
+/// Messages are written to the standard streams by default, matching the output
+/// of previous versions. Embedders can route them into their own logging system:
+///
+/// ```swift
+/// Log.handler = { level, message in
+///     logger.log(level: level == .error ? .error : .warning, "\(message)")
+/// }
+/// ```
+///
+/// Or silence them entirely:
+///
+/// ```swift
+/// Log.handler = Log.silent
+/// ```
+public enum Log {
+
+    public enum Level: Int, Comparable, Hashable, CaseIterable, Sendable {
+        case info
+        case warning
+        case error
+
+        public static func < (lhs: Self, rhs: Self) -> Bool {
+            lhs.rawValue < rhs.rawValue
+        }
+    }
+
+    public typealias Handler = @Sendable (Level, String) -> Void
+
+    /// Receives every message emitted while parsing and rendering.
+    ///
+    /// Defaults to `standardStreams()`. Assign once during startup; the property
+    /// is safe to access from multiple threads but messages emitted while it is
+    /// being replaced may reach either handler.
+    public static var handler: Handler {
+        get {
+            let handler = LogSink.handler
+            return { handler($0.sink, $1) }
+        }
+        set {
+            LogSink.handler = { newValue(Level($0), $1) }
+        }
+    }
+
+    /// Writes `info` messages to standard output and everything else to standard error.
+    ///
+    /// `warning` messages are prefixed with `Warning:`.
+    /// - Parameter minimumLevel: messages below this level are discarded.
+    public static func standardStreams(minimumLevel: Level = .info) -> Handler {
+        let handler = LogSink.standardStreams(minimumLevel: minimumLevel.sink)
+        return { handler($0.sink, $1) }
+    }
+
+    /// Discards every message.
+    public static let silent: Handler = { _, _ in }
+}
+
+public extension Log {
+
+    /// Emits a message that forms part of the expected output.
+    static func info(_ message: String) {
+        LogSink.info(message)
+    }
+
+    /// Emits a message about content that was handled in a degraded way.
+    /// The `Warning:` prefix is applied by the handler.
+    static func warning(_ message: String) {
+        LogSink.warning(message)
+    }
+
+    /// Emits a message about content that could not be handled.
+    static func error(_ message: String) {
+        LogSink.error(message)
+    }
+}
+
+private extension Log.Level {
+
+    var sink: LogSink.Level {
+        switch self {
+        case .info: .info
+        case .warning: .warning
+        case .error: .error
+        }
+    }
+
+    init(_ level: LogSink.Level) {
+        switch level {
+        case .info: self = .info
+        case .warning: self = .warning
+        case .error: self = .error
+        }
+    }
+}
diff --git a/SwiftDraw/Sources/Renderer/Renderer.SFSymbol.swift b/SwiftDraw/Sources/Renderer/Renderer.SFSymbol.swift
index b0d1bd6..c62c7fd 100644
--- a/SwiftDraw/Sources/Renderer/Renderer.SFSymbol.swift
+++ b/SwiftDraw/Sources/Renderer/Renderer.SFSymbol.swift
@@ -95,7 +95,7 @@ public struct SFSymbolRenderer {
     private func makeVariant(regular: URL, explicit: URL?, scale: StrokeWidthScale?, variant: Variant) throws -> DOM.SVG? {
         if let explicit {
             if scale != nil {
-                print("Warning:", "explicit --\(variant.rawValue) overrides --\(variant.rawValue)-stroke-width.", to: &.standardError)
+                LogSink.warning("explicit --\(variant.rawValue) overrides --\(variant.rawValue)-stroke-width.")
             }
             return try DOM.SVG.parse(fileURL: explicit)
         }
@@ -103,7 +103,7 @@ public struct SFSymbolRenderer {
         let dom = try DOM.SVG.parse(fileURL: regular)
         let count = StrokeWidthScaler.scale(dom, by: scale)
         if count == 0 {
-            print("Warning:", "--\(variant.rawValue)-stroke-width has no effect: source SVG has no stroke-width values.", to: &.standardError)
+            LogSink.warning("--\(variant.rawValue)-stroke-width has no effect: source SVG has no stroke-width values.")
         }
         return dom
     }
@@ -232,7 +232,7 @@ extension SFSymbolRenderer {
         let isSFSymbolLayer = containsAcceptedName(layer.class)
         guard isSFSymbolLayer || layer.opacity > 0 else { return [] }
         guard layer.mask == nil else {
-            print("Warning:", "mask unsupported in SF Symbols.", to: &.standardError)
+            LogSink.warning("mask unsupported in SF Symbols.")
             return []
         }
 
@@ -296,7 +296,7 @@ extension SFSymbolRenderer {
         }
         return result
 #else
-        print("Warning:", "clip-path requires CoreGraphics.", to: &.standardError)
+        LogSink.warning("clip-path requires CoreGraphics.")
         return paths
 #endif
     }
@@ -317,7 +317,7 @@ extension SFSymbolRenderer {
 #if canImport(CoreGraphics)
             return expandOutlines(for: shape.path, stroke: stroke)
 #else
-            print("Warning:", "expanding stroke outlines requires macOS.", to: &.standardError)
+            LogSink.warning("expanding stroke outlines requires macOS.")
             return nil
 #endif
         }
@@ -332,7 +332,7 @@ extension SFSymbolRenderer {
         let cgPath = CGProvider().createPath(from: text, at: point, with: attributes)
         return cgPath?.makePath()
 #else
-        print("Warning:", "expanding text outlines requires macOS.", to: &.standardError)
+        LogSink.warning("expanding text outlines requires macOS.")
         return nil
 #endif
     }
@@ -410,11 +410,11 @@ extension SFSymbolRenderer {
 
         switch variant {
         case .regular:
-            print("Alignment: --insets \(top),\(left),\(bottom),\(right)")
+            LogSink.info("Alignment: --insets \(top),\(left),\(bottom),\(right)")
         case .ultralight:
-            print("Alignment: --ultralight-insets \(top),\(left),\(bottom),\(right)")
+            LogSink.info("Alignment: --ultralight-insets \(top),\(left),\(bottom),\(right)")
         case .black:
-            print("Alignment: --black-insets \(top),\(left),\(bottom),\(right)")
+            LogSink.info("Alignment: --black-insets \(top),\(left),\(bottom),\(right)")
         }
     }
 
diff --git a/SwiftDraw/Tests/CommandLine/CommandLine.ArgumentsTests.swift b/SwiftDraw/Tests/CommandLine/CommandLine.ArgumentsTests.swift
index 756e66f..bcee54e 100644
--- a/SwiftDraw/Tests/CommandLine/CommandLine.ArgumentsTests.swift
+++ b/SwiftDraw/Tests/CommandLine/CommandLine.ArgumentsTests.swift
@@ -44,6 +44,8 @@ final class CommandLineArgumentsTests: XCTestCase {
         modifiers = try CommandLine.parseModifiers(from: ["--ultralight-insets", "a", "--black-insets", "b", "--hide-unsupported-filters", "--legacy"])
         XCTAssertEqual(modifiers, [.ultralightInsets: "a", .blackInsets: "b", .hideUnsupportedFilters: nil, .legacy: nil])
 
+        modifiers = try CommandLine.parseModifiers(from: ["--format", "png", "--quiet"])
+        XCTAssertEqual(modifiers, [.format: "png", .quiet: nil])
     }
 
     func testParseModifiersThrowsForOddPairs() {
diff --git a/SwiftDraw/Tests/CommandLine/CommandLine.ConfigurationTests.swift b/SwiftDraw/Tests/CommandLine/CommandLine.ConfigurationTests.swift
index 6f1a1d3..8a2119b 100644
--- a/SwiftDraw/Tests/CommandLine/CommandLine.ConfigurationTests.swift
+++ b/SwiftDraw/Tests/CommandLine/CommandLine.ConfigurationTests.swift
@@ -83,6 +83,14 @@ final class CommandLineConfigurationTests: XCTestCase {
         XCTAssertEqual(config.format, .png)
     }
 
+    func testParseConfigurationLogLevel() throws {
+        let config = try parseConfiguration("swiftdraw", "file.svg", "--format", "pdf")
+        XCTAssertEqual(config.logLevel, .info)
+
+        let quiet = try parseConfiguration("swiftdraw", "file.svg", "--format", "pdf", "--quiet")
+        XCTAssertEqual(quiet.logLevel, .error)
+    }
+
     func testParseConfigurationThrows() {
         XCTAssertThrowsError(try parseConfiguration())
         XCTAssertThrowsError(try parseConfiguration("swiftdraw", "file.svg"))
diff --git a/SwiftDraw/Tests/LogTests.swift b/SwiftDraw/Tests/LogTests.swift
new file mode 100644
index 0000000..1feba81
--- /dev/null
+++ b/SwiftDraw/Tests/LogTests.swift
@@ -0,0 +1,190 @@
+//
+//  LogTests.swift
+//  SwiftDraw
+//
+//  Created by Simon Whitty on 26/8/26.
+//  Copyright 2026 Simon Whitty
+//
+//  Distributed under the permissive zlib license
+//  Get the latest version from here:
+//
+//  https://github.com/swhitty/SwiftDraw
+//
+//  This software is provided 'as-is', without any express or implied
+//  warranty.  In no event will the authors be held liable for any damages
+//  arising from the use of this software.
+//
+//  Permission is granted to anyone to use this software for any purpose,
+//  including commercial applications, and to alter it and redistribute it
+//  freely, subject to the following restrictions:
+//
+//  1. The origin of this software must not be misrepresented; you must not
+//  claim that you wrote the original software. If you use this software
+//  in a product, an acknowledgment in the product documentation would be
+//  appreciated but is not required.
+//
+//  2. Altered source versions must be plainly marked as such, and must not be
+//  misrepresented as being the original software.
+//
+//  3. This notice may not be removed or altered from any source distribution.
+//
+
+import Foundation
+import SwiftDrawDOM
+import Testing
+@testable import SwiftDraw
+
+struct LogLevelTests {
+
+    @Test
+    func levelsAreOrderedBySeverity() {
+        #expect(Log.Level.info < Log.Level.warning)
+        #expect(Log.Level.warning < Log.Level.error)
+        #expect(Log.Level.allCases == [.info, .warning, .error])
+    }
+}
+
+/// The handler is process wide, so this is the only suite that replaces it.
+/// Messages emitted by tests running in parallel are ignored, never asserted on.
+@Suite(.serialized)
+struct LogTests {
+
+    @Test
+    func handlerReceivesEveryLevel() {
+        let messages = Messages()
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = { messages.append($0, $1) }
+        let handler = Log.handler
+
+        handler(.info, "\(token) alignment")
+        handler(.warning, "\(token) unsupported")
+        handler(.error, "\(token) invalid")
+
+        #expect(messages.lines == [
+            "info: \(token) alignment",
+            "warning: \(token) unsupported",
+            "error: \(token) invalid"
+        ])
+    }
+
+    @Test
+    func handlerCanBeRestored() {
+        let messages = Messages()
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = { messages.append($0, $1) }
+        let restored = Log.handler
+
+        Log.handler = Log.silent
+        Log.handler = restored
+
+        Log.handler(.warning, "\(token) unsupported")
+
+        #expect(messages.lines == ["warning: \(token) unsupported"])
+    }
+
+    @Test
+    func silentDiscardsMessages() {
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = Log.silent
+
+        Log.handler(.info, "\(token) alignment")
+        Log.handler(.warning, "\(token) unsupported")
+        Log.handler(.error, "\(token) invalid")
+    }
+
+    @Test
+    func emittedMessagesReachTheHandler() {
+        let messages = Messages()
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = { messages.append($0, $1) }
+
+        LogSink.info("\(token) alignment")
+        LogSink.warning("\(token) unsupported")
+        LogSink.error("\(token) invalid")
+
+        #expect(messages.lines == [
+            "info: \(token) alignment",
+            "warning: \(token) unsupported",
+            "error: \(token) invalid"
+        ])
+    }
+
+    // Commands are only generated when CoreGraphics is available; the renderer
+    // emits no warnings on other platforms.
+#if canImport(CoreGraphics)
+    @Test
+    func renderingWarningsReachTheHandler() throws {
+        let messages = Messages(filter: nil)
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = { messages.append($0, $1) }
+
+        let xml = #"""
+        <?xml version="1.0" encoding="UTF-8"?>
+        <svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
+            <defs>
+                <linearGradient id="fade">
+                    <stop offset="0" stop-color="black" stop-opacity="0"/>
+                    <stop offset="1" stop-color="black" stop-opacity="1"/>
+                </linearGradient>
+            </defs>
+            <rect width="100" height="100" fill="url(#fade)"/>
+        </svg>
+        """#
+
+        let dom = try DOM.SVG.parse(data: Data(xml.utf8))
+        _ = SVG(dom: dom, options: [.disableTransparencyLayers])
+
+        #expect(messages.lines.contains("warning: PDF does not support gradients with stop-opacity"))
+    }
+#endif
+
+    @Test
+    func parsingErrorsReachTheHandler() throws {
+        let messages = Messages(filter: nil)
+        let original = Log.handler
+        defer { Log.handler = original }
+
+        Log.handler = { messages.append($0, $1) }
+
+        XMLParser.logParsingError(for: XMLParser.Error.invalid, filename: "empire.svg")
+
+        #expect(messages.lines.contains("error: [parsing error] empire.svg  error: invalid"))
+    }
+}
+
+private let token = "LogTests"
+
+private final class Messages: @unchecked Sendable {
+
+    init(filter: String? = token) {
+        self.filter = filter
+    }
+
+    var lines: [String] {
+        lock.lock()
+        defer { lock.unlock() }
+        return stored
+    }
+
+    @Sendable
+    func append(_ level: Log.Level, _ message: String) {
+        guard filter.map(message.contains) ?? true else { return }
+        lock.lock()
+        defer { lock.unlock() }
+        stored.append("\(level): \(message)")
+    }
+
+    private let filter: String?
+    private let lock = NSLock()
+    private var stored = [String]()
+}