Native Swift 6 & macOS 14+ Low-Memory Compilation Zero Subscriptions

Bookwiz

The All-in-One Studio for Serious Novelists

Stop juggling five disconnected subscription apps to write, edit, and publish your books. Bookwiz unites structural beat planning, multi-POV visual timelines, universe bibles, automated continuity diagnostics, and print/digital compilation into a single, lightning-fast native macOS engine.

Engineered from day one with strict low-memory compilation mandates so that writers and independent developers—even those working on the most modest, entry-level Macs—can compile, customize, and run the complete studio with zero friction.

Explore Features The Low-Memory Mandate Architectural Pillars
1 App
Unified Workflow

Replaces 5+ fragmented apps from first outline to final release.

8 GB
RAM Friendly

Built & profiled under virtualization for base-model hardware.

73
Decoupled Protocols

Zero tight coupling and 100% constructor dependency injection.

1,250
Automated Tests

Rigorous test suites with zero tolerance for silent data corruption.

The Pain Points of Modern Novelists

The Exhaustion of the Fragmented Toolchain

Today's authors are forced to stitch together a fragile patchwork of incompatible software. The cognitive overhead, subscription fatigue, and constant context switching drain the very creative energy needed to finish a manuscript.

The Fragmented 5-App Stack

How authors are forced to work today
  • ✕
    Outlining in Disconnected Plotters: Beat boards and timelines in external apps (Plottr, Aeon, index cards) don't synchronize with the manuscript, quickly falling out of date as the story evolves.
  • ✕
    Worldbuilding in Isolated Wikis: Lore entries in Notion, Obsidian, or Word files are detached from the text editor. You have to manually search your notes to remember a character's eye color or sword name.
  • ✕
    Manual Continuity Tracking: Plot holes, impossible travel speeds, dead characters speaking, and items appearing in two places at once slip through unless manually tracked in complex spreadsheets.
  • ✕
    Expensive External Editing Services: Pacing analysis, emotional arc tracking, and stylistic audits require expensive monthly subscriptions or tedious manual charting.
  • ✕
    Costly Export & Formatting Paywalls: Compiling clean EPUBs, print-ready PDF interiors, and multi-voice audiobook scripts requires separate $150–$250 desktop publishing apps or messy web converters.

The Bookwiz Unified Engine

One cohesive, native creative studio
  • ✓
    Live Beat Fulfillment & Dynamic Outlines: Your outline, acts, and scenes live in direct communion with your text. Beat fulfillment auditors track story milestones in real time.
  • ✓
    Universe Bible & Ambient Context: Your lore graph, character bios, and world rules are embedded into the writing environment with instant asynchronous token lookup.
  • ✓
    Automated Knowledge Firewall & Conflict Detectors: Intelligent background watchers calculate travel times, audit physical attributes, and gate item possessions across books in a series.
  • ✓
    Built-in Pacing & Stylistic Topography: Emotional valence curves, readability metrics, and crutch phrase/slang analyzers run locally on your device with zero cloud lag.
  • ✓
    Comprehensive Multi-Format Publishing: One-click export to validated EPUB 3, pre-flight audited print PDF, DOCX with comments, and SSML multi-voice audiobook scripts.
End-to-End Capabilities

A Complete Engine for the Entire Novel Lifecycle

Every feature in Bookwiz is built as a focused, protocol-isolated domain service. Here is how Bookwiz powers your workflow from your first brainstorm to publication day.

Outlining & Beats

Structural Narrative Flow

Structure your novel with industry-standard frameworks (Hero's Journey, 3-Act, 4-Act, Save the Cat) or custom story arcs.

  • Automated beat fulfillment validation.
  • Orphaned scene pools & drag-and-drop reordering.
  • Act and scene word-count target pacing.
BeatFulfillmentChecking

Visual Timelines

Multi-POV Synchronization

Track chronological vs. narrative sequence across complex fictional calendars with multi-character branch tracking.

  • Multi-POV automated scene generation from events.
  • Custom fictional calendars with leap year validation.
  • Flashback branch & micro-event collision detection.
TimelineSceneGenerating

Knowledge Firewall

Continuity & World Rules

Prevent plot holes and continuity drift across massive standalone books and multi-volume book series.

  • Character physical attribute & trait inspection.
  • Travel transit physics & speed conflict detection.
  • Temporal item possession boundary gating.
KnowledgeFirewalling

Pacing & Diagnostics

Emotional Topography

Gain developmental insights into your manuscript's rhythm and readability with continuous background analyzers.

  • Chapter-by-chapter emotional valence curves.
  • Crutch phrases, period slang & idiom auditing.
  • Primary cast validation & dialogue voice tracking.
ManuscriptDiagnosticCoordinating

Native Pro Writing

Distraction-Free Workspace

A focused, responsive rich-text and markdown editor designed for long-form speed without web-wrapper sluggishness.

  • Streaming dictation vernacular sanitization.
  • Bidirectional auto-repairing footnote system.
  • Ambient context panel for active character/lore stats.
DictationVernacularSanitizing

Publishing Pipeline

Multi-Format Compiling

Produce industry-standard deliverables with professional typography and pre-flight asset verification.

  • Validated EPUB 3 compiler with asset bundling.
  • Print-ready PDF generator with DPI/color checks.
  • SSML audiobook exporter & DOCX comment round-tripping.
EpubCompiling & PdfExporting
Core Engineering Philosophy

The Low-Memory Mandate: Software for Everyone

"Creative software should never be a luxury gated behind high-end $2,500 machines or recurring monthly subscriptions. Anyone with the drive to write a novel deserves tools that are fast, dependable, and compile cleanly on whatever hardware they have."

Bookwiz was built under active virtualization on an 8 GB RAM machine. In modern Swift development, the compiler's Abstract Syntax Tree (AST) type-checker can quickly consume gigabytes of memory when expressions are deeply nested or SwiftUI view bodies grow large. On modest hardware, this leads to OS-level page swapping, thermal throttling, and multi-minute compilation hangs.

To guarantee that anyone can compile and run Bookwiz smoothly on base-model Apple Silicon or older Macs, every single line of code in Bookwiz obeys four strict technical mandates:

Rule 1

Explicit Types Everywhere

Local variables and closures require explicit type annotations. The compiler is never forced to solve complex generic inference equations, keeping AST memory rock-bottom.

Rule 2

40-Line SwiftUI Body Limit

Any SwiftUI var body exceeding 40 lines must be decomposed into typed private subviews, ensuring file compilation finishes in under 30 seconds.

Rule 3

Flattened Generics

Generics are restricted from nesting deeper than two levels. Explicit intermediate type bindings prevent exponential compiler memory consumption.

Rule 4

350-Line File Ceilings

Strict Single Responsibility limits. Files are decomposed using the TypeName+Concern.swift pattern to prevent memory thrashing during batch builds.

The result? Clean, readable, lightning-fast Swift code that builds in seconds, runs with zero memory leaks, and delivers desktop-class performance without demanding high-end hardware.

Robust Foundation

The Five Architectural Pillars

Bookwiz is architected with strict decoupling, ensuring every layer is fully testable, maintainable, and free of global state.

Pillar I

Single Responsibility (SRP)

Every file owns exactly one concern with enforced line limits: Protocols ≤ 40 lines, Models ≤ 150, Services ≤ 250, Views ≤ 150, and Tests ≤ 200 lines.

Pillar II

Protocol Boundaries

All inter-layer communication crosses through 73 gerund protocols (ContinuityConflictDetecting, EpubCompiling). No cross-target concrete coupling.

Pillar III

Zero Tight Coupling

BookwizCore has zero imports of SwiftUI, AppKit, or Combine. Core async streams use native Swift 6 AsyncStream exclusively.

Pillar IV

Modern Swift 6 & Zero Silent Fails

Targets modern macOS 14+ with zero try? silent error eating on persistence paths. Production logging uses unified os.Logger.

Pillar V

Complete Test Isolation

1,250 automated unit tests across 362 test files. Built with both standard XCTest and a custom, lightweight zero-dependency test runner.

Pillar VI

Constructor Injection

Zero .shared singletons and zero global mutable state. Every service receives its dependencies cleanly through its initializer.

ManuscriptDiagnosticCoordinator.swift — Constructor Dependency Injection Pillar II & III Compliant 
// Sources/BookWizCore/Services/ManuscriptDiagnosticCoordinator.swift
public struct ManuscriptDiagnosticCoordinator: ManuscriptDiagnosticCoordinating {
    private let readabilityAnalyzer: ReadabilityAnalyzing
    private let accessibilityAuditor: AccessibilityAuditing
    private let continuityDetector: ContinuityConflictDetecting
    private let locationConflictDetector: CharacterLocationConflictDetecting
    private let itemPossessionDetector: ItemPossessionConflictDetecting
    private let knowledgeFirewall: KnowledgeFirewalling

    public init(
        readabilityAnalyzer: ReadabilityAnalyzing = ReadabilityAnalyzer(),
        accessibilityAuditor: AccessibilityAuditing = AccessibilityAuditor(),
        continuityDetector: ContinuityConflictDetecting = ContinuityConflictDetector(),
        locationConflictDetector: CharacterLocationConflictDetecting = CharacterLocationConflictDetector(),
        itemPossessionDetector: ItemPossessionConflictDetecting = ItemPossessionConflictDetector(),
        knowledgeFirewall: KnowledgeFirewalling = KnowledgeFirewallEngine()
    ) {
        self.readabilityAnalyzer = readabilityAnalyzer
        self.accessibilityAuditor = accessibilityAuditor
        self.continuityDetector = continuityDetector
        self.locationConflictDetector = locationConflictDetector
        self.itemPossessionDetector = itemPossessionDetector
        self.knowledgeFirewall = knowledgeFirewall
    }
}