A Go port of doxx - Lightning-fast, terminal-native document viewer for Microsoft Word files

doxx-go brings the power of the original Rust doxx to the Go ecosystem, providing beautiful terminal-based viewing of Microsoft Word documents with zero dependencies on Microsoft Office.

Complete feature parity with the original Rust implementation:

• 🎨 Beautiful terminal rendering with syntax highlighting and formatting
• 📊 Professional table display with smart alignment and Unicode borders
• 📋 Nested list support with proper indentation and multi-level hierarchy
• 🔍 Full-text search with highlighting and context
• 📑 Document outline for quick navigation
• 🎯 Multiple view modes — document, outline, search, and help
• 📋 Copy to clipboard - Copy rendered content directly from the terminal UI
• 📝 Multiple export formats - Markdown, CSV, JSON, and plain text
• ⚡ XML-based parsing - Robust text extraction from DOCX internal structure

# Clone the repository
git clone https://github.com/keskinonur/doxx-go.git
cd doxx-go

# Build the binary
go build -o doxx cmd/doxx/main.go

# Or install directly
go install ./cmd/doxx

Download the latest release for your platform from the releases page.

make build      # Build the binary
make install    # Install to $GOPATH/bin
make run FILE=document.docx  # Run with a file

./quickstart.sh  # Automated setup and dependencies

# View a document interactively
doxx quarterly-report.docx

# Start with outline view
doxx document.docx --outline

# Search for specific content
doxx contract.docx --search "payment terms"

# Force interactive UI mode
doxx document.docx --force-ui

# Export to different formats
doxx spreadsheet.docx --export csv > data.csv           # Tables only
doxx report.docx --export markdown > report.md          # Full document
doxx document.docx --export json > structure.json       # Complete structure  
doxx document.docx --export text > plain.txt            # Plain text

Important: CSV export only outputs table data. For documents without tables, use text, markdown, or json formats.

# Search without UI (for scripting)
doxx document.docx --search "error" --no-ui

# Combine search with export
doxx document.docx --search "quarterly" --export json

# Process multiple files
for file in *.docx; do doxx "$file" --export text > "${file%.docx}.txt"; done

The project includes comprehensive test fixtures from the original doxx repository:

# Test with original doxx fixtures
ls test-fixtures/
# minimal.docx              - Basic parsing test
# tables-heavy.docx         - Complex table parsing  
# headings-hierarchy.docx   - Outline generation
# formatting-showcase.docx  - Text formatting
# lists-comprehensive.docx  - List structures
# unicode-special.docx      - International characters
# business-report.docx      - Real-world document
# export-test.docx          - Export validation

# Basic document parsing
./build/doxx test-fixtures/minimal.docx --export text

# Table extraction and CSV export
./build/doxx test-fixtures/tables-heavy.docx --export csv

# Heading detection and outline
./build/doxx test-fixtures/headings-hierarchy.docx --export markdown

# Search functionality
./build/doxx test-fixtures/business-report.docx --search "revenue"

# Unicode and special characters
./build/doxx test-fixtures/unicode-special.docx --export json

# Comprehensive format testing
./build/doxx test-fixtures/export-test.docx --export markdown

make test               # Run unit tests
make test-coverage      # Generate coverage report
make benchmark          # Performance benchmarks

doxx-go/
├── cmd/
│   └── doxx/
│       └── main.go          # CLI entry point with Cobra
├── internal/
│   ├── document/
│   │   ├── parser.go        # DOCX parsing with XML extraction
│   │   └── parser_test.go   # Unit tests
│   ├── ui/
│   │   └── app.go           # Terminal UI with Bubble Tea
│   └── export/
│       └── export.go        # Multi-format export (MD, CSV, JSON, Text)
├── test-fixtures/           # Original doxx test files
├── build/                   # Compiled binaries
├── go.mod                   # Go module definition
├── Makefile                 # Build automation
└── README.md

This Go port maintains the same architecture as the original Rust implementation:

• Document Parsing: Uses nguyenthenguyen/docx for DOCX file access with custom XML parsing for robust text extraction
• Terminal UI: Built with charmbracelet/bubbletea for beautiful cross-platform interfaces
• Smart Tables: Intelligent data type detection and alignment (numbers right-aligned, booleans centered)
• Export Pipeline: Clean separation of concerns for different export formats

• Parses Word document XML structure directly
• Extracts clean text from <w:t> tags
• Preserves formatting and style information
• Handles complex document structures

• Automatically detects data types (numbers, currency, percentages, dates, booleans)
• Applies intelligent alignment based on content type
• Unicode borders for professional rendering
• Proper CSV export with data type preservation

• Case-insensitive full-text search across paragraphs and tables
• Context-aware result highlighting with **bold** markup
• Navigate between results with n/p keys
• Location information for precise navigation

• Markdown: Preserves formatting with proper table alignment indicators
• CSV: Extracts only tables for data analysis workflows (empty if no tables)
• JSON: Complete document structure with metadata and typing information
• Text: Clean plain text output suitable for piping and automation

Following the original doxx roadmap:

• AI integration for document summarization
• Hyperlink support and navigation
• Image descriptions and alt-text
• Themes and color customization
• Web interface for browser viewing
• Plugin system for extensions

MIT License - See LICENSE file for details

• Original doxx by @bgreenwell
• Built with Bubble Tea by Charm
• Test fixtures from the original doxx repository
• Inspired by the terminal-first development philosophy

Contributions are welcome! This project maintains compatibility with the original doxx.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/AmazingFeature)
3. Add tests for new functionality
4. Ensure all tests pass (make test)
5. Commit your changes (git commit -m 'Add some AmazingFeature')
6. Push to the branch (git push origin feature/AmazingFeature)
7. Open a Pull Request

git clone https://github.com/keskinonur/doxx-go.git
cd doxx-go
make deps                # Download dependencies
make test                # Run tests
make build               # Build binary
./build/doxx test-fixtures/minimal.docx  # Test with sample file

Made with ❤️ for developers who live in the terminal