By David A Cornelson — Aug 19, 2025

Announcing Sharpee v1.0.0-alpha.1

By Claude Opus 4.1 and David Cornelson

Today marks an important milestone in the Sharpee project as we release our first alpha version. After months of careful architecture design and implementation, we're ready to share our vision for a modern, Typescript-based interactive fiction platform.

Why Sharpee?

Interactive fiction has a rich history spanning decades, from Zork to modern narrative games. Yet many IF development tools still reflect design decisions from the 1980s and 90s. Sharpee re-imagines interactive fiction development with modern software engineering principles:

Type Safety First: Full Typescript implementation catches errors at compile time.
Event-Driven Architecture: Every game state change is an immutable event, enabling features like unlimited undo/redo.
Extensible by Design: Add magic systems, combat, economics, or any mechanic through clean plugin interfaces.
Test-Driven Development: 2,700+ tests ensure reliability
Text Service: queries world model and event source to report game state. Authors can can create their own Text Service for any type of client.

What's in Alpha 1?

This release establishes the core foundation:

The Engine

Our event-sourced architecture treats every game action as an immutable event. This isn't just a technical detail—it fundamentally changes what's possible. Perfect save/restore, replay systems, and debugging tools all become trivial when your entire game history is a sequence of events.

The World Model

Entities in Sharpee aren't just objects with properties. They're compositions of traits and behaviors that interact dynamically. A mirror isn't hardcoded to be reflective—it has a mirror trait that provides that behavior. This composability means you can create entirely new types of objects without touching the core engine.

Natural Language Understanding

Our semantic parser doesn't just match patterns—it understands intent. "Take the red ball" and "pick up the crimson sphere" can resolve to the same action because the parser works with meaning, not just syntax.

The Standard Library

We've implemented 40+ standard actions that form the vocabulary of interactive fiction: take, drop, examine, go, open, close, wear, eat, and many more. Each action follows our validate/execute pattern, ensuring consistent behavior across the system.

A Different Approach

Sharpee takes some unconventional approaches that we believe will pay dividends:

Separation of Concerns: The physical world model is completely separate from meta-game features like scoring or saving. This clean separation makes the code base easier to understand and extend.

No Global State: Everything flows through events. There's no hidden state to worry about, no globals to accidentally mutate. This makes Sharpee games inherently more predictable and debuggable.

Extension-First Design: Rather than building every possible feature into the core, we've created a powerful extension system.

The Road Ahead

This alpha release is just the beginning. We're working on:

The Forge API: A fluent, author-friendly API for creating games without diving into Typescript.
Story Showcases: Completing our potential IF Comp 2025 - Reflections story and rebuilding sample stories like Cloak of Darkness.
Platform Expansion: Web and Electron clients for broader reach.
Visual Tools: VS Code Plugin for syntax highlighting and compile/test features.

For Early Adopters

If you're technically inclined and interested in the future of interactive fiction, we'd love your feedback on this alpha. The architecture is stable, the tests are passing, and the extension system is ready for experimentation.

Some ideas to try:

Port a classic IF game to see how Sharpee handles it.
Create an extension for your favorite game mechanic.
Stress-test the parser with complex commands.
Build a small story to explore the authoring experience.

A Personal Note

Interactive fiction has always been about pushing boundaries—not just in storytelling, but in what's technically possible with text. With Sharpee, we're trying to push those boundaries again, bringing modern engineering practices to a beloved genre.

This alpha release represents thousands of hours of design, development, and testing. It's built on lessons learned from decades of IF development, but it's not afraid to challenge conventional wisdom when we believe there's a better way.

Get Started

Ready to explore? Check out:

[GitHub Repository](https://github.com/ChicagoDave/sharpee)
[Release Notes](https://github.com/ChicagoDave/sharpee/releases/tag/v1.0.0-alpha.1)
[Documentation](https://github.com/ChicagoDave/sharpee/tree/main/docs)

We're excited to see what the interactive fiction community will build with Sharpee. The foundation is solid, the architecture is clean, and the possibilities are endless.

Welcome to the future of interactive fiction development.

David Cornelson
Creator of Sharpee

Download: [Sharpee v1.0.0-alpha.1](https://github.com/ChicagoDave/sharpee/releases/tag/v1.0.0-alpha.1)
License: MIT
Requirements: Node.js 18+, pnpm 8+
Status: Alpha (not for production use)