Native x64 Port of Microsoft Word for Windows 1.1a

This repository, maintained by jmarshall23, provides a fully functional, native 64-bit port of Microsoft Word for Windows 1.1a (historically known by the codename Opus).

The project achieves this by compiling the original source code and resources while swapping out obsolete 16-bit assembly, segmented memory architectures, and Win16 platform dependencies with modern equivalents.

Crucial Distinction: This project is not an emulator, nor is it a modern rewrite using contemporary editor controls. It is the original application logic running as a native 64-bit Windows executable.

🛠️ System Requirements

To successfully build this project, ensure you have the following:

OS: 64-bit Windows
IDE: Visual Studio 2022 (with Desktop development with C++ workload)
SDK: Windows 10 or 11 SDK (installed via Visual Studio)
Build Tool: CMake version 3.25 or higher
Shell: PowerShell

🚀 Build and Execution Guide

Follow these steps in a PowerShell prompt to compile and launch the application:

# 1. Clone the source code
git clone https://github.com/jmarshall23/msword.git
Set-Location msword\src

# 2. Configure the project using the x64-debug preset
cmake --preset x64-debug

# 3. Compile the binaries
cmake --build --preset x64-debug

# 4. Execute the application
..\bin\WORD1.exe

Note: For a performance-optimized version, simply replace debug with release in the commands above.

Alternatively, you can open the generated solution file located at out\MicrosoftWordX64Port.sln and set WORD1 as your startup project.

🧪 Testing Framework

The project includes a comprehensive test suite to ensure the port maintains the original's integrity. You can run these from the root directory:

ctest --test-dir .\out -C Debug --output-on-failure

(If you are currently inside the src folder, use ..\out instead).

The test suite validates:

The ported x64 runtime.
Original command tables and data structures.
Process initialization.
Automated UI interactions (e.g., $\text{typing} \rightarrow \text{selection} \rightarrow \text{formatting} \rightarrow \text{saving}$ ).

📂 Project Architecture

The repository is organized as follows:

Path	Purpose
`src/Opus/`	The core original Word/Opus source and resources.
`src/OpusEtAl/`	Supporting libraries, build inputs, and legacy tools.
`src/OpusProg/`	Historical documentation for the program.
`src/port/original/`	The x64 compatibility layer and translated routines.
`src/port/tools/`	Modern replacements for old build-time utilities.
`src/cmake/`	Helpers for generating sources and resources.
`out/`	Generated Visual Studio solution and CMake cache.
`build/`	Diagnostics, PDBs, probes, and intermediate files.
`bin/`	The final runtime files and the `.exe`.

⚙️ How the Port Functions

The original C code and resource files serve as the "source of truth." The porting process focuses on bridging the gap between $\text{Win16}$ and $\text{Win64}$ .

Technical Translation

The transition involves moving from ~~16-bit segmented memory~~ to a flat 64-bit address space: $\text{Segment:Offset} \implies \text{Flat 64-bit Pointer}$

Key Implementation Details:

Assets: Bitmaps, dialogs, and cursors are rebuilt using native host tools via the CMake graph.
Reference: CMake tracks the legacy assembly tree for reference, but these are ~~not~~ compiled into the final targets.
Safety: Unit and smoke tests ensure that original algorithms remain unchanged.

🎯 Build Targets

Target	Description
`WORD1`	The primary native x64 Microsoft Word executable.
`opus_original_engine`	The core application engine compiled for x64.
`opus_x64_runtime`	The native runtime handling translated assembly.
`opus_word1_ui_test`	The driver for automated end-to-end UI testing.
`legacy_sources`	A collection of original assembly for IDE reference.

To build a specific target: cmake --build --preset x64-debug --target WORD1

🤝 Contributing & Legal

Contribution Guidelines

When submitting changes, please adhere to these principles:

Behavior: Maintain the original Word functionality.
Safety: Ensure all native interfaces are pointer-width safe.
Isolation: Keep Windows API adaptations confined to the port boundary.
Verification: Provide focused tests for any new translations.

Copyright Notice

The historical source files contain their original copyright notices from Microsoft and other third parties. Note: This repository does not currently provide a top-level license; users should verify all legal rights before redistributing binaries or source code.