Tense Shifting For Time Simulation In Text-Based Systems
There is a growing push in certain interactive fiction and tabletop systems to treat verb tense not as a grammatical quirk but as an actual mechanism for simulating time passage. The idea sounds simpler than it executes. You have three primary tenses available to you — simple present, present continuous, past simple — and the claim is that they can be layered to create a convincing illusion of forward and backward temporal movement within a fictional space. It works sometimes. It falls apart constantly when you do not plan for it. I spent about eighteen months building a tense-tracking system into a custom text adventure engine. We called it the temporal stack. The concept was straightforward on paper: every action you log gets tagged with a tense, and the narrator pulls from the stack to describe what just happened, what is happening now, and what is still ongoing. In practice, the stack collapsed every time you had overlapping actions. A character drawing a sword while walking toward a door created a conflict between present continuous and simple present that nobody wrote a parser for. I ended up creating a priority queue based on action completion time, which means you basically write a tiny scheduler inside your prose logic.
They Are Planning A New Era In Verb Tenses How The Simple Present Present Continuous And Past Simple Can Simulate Time P
The core mechanism relies on assigning semantic weight to each tense. Simple present handles habitual or state-based descriptions. It is what you use for things that are true regardless of the current moment — "the door is locked," "she carries a dagger." Present continuous handles active, in-progress events — "she is unlocking the door," "rain is falling against the glass." Past simple handles completed actions that leave a trace — "the guard fell," "the latch clicked shut." When you sequence these correctly across a narrative beat, the reader unconsciously accepts the passage of time because the grammar itself does the heavy lifting. Here is the part most people skip. You cannot use all three tenses at once on the same subject without creating cognitive dissonance. If you write "He opens the door and is opening it slowly," the reader stalls. You need to decide whether the subject is in a completed state or an ongoing process before you write the sentence. My workaround for the overlapping action problem I described above was to force a tense resolution step before any output gets rendered. The engine checks whether two concurrent actions share a subject or object. If they do, the earlier action gets promoted to past simple and the later action stays in present continuous. This creates an accidental but effective chronological ordering that reads naturally.
Building The System
You do not need a custom engine to use this approach. It works in any text generation context where you control the narrative voice. The key steps are mapping every event to a tense label, maintaining a timeline buffer that tracks when each event occurred relative to the current narrative moment, and then selecting the appropriate tense when rendering descriptions. The timeline buffer is where most implementations fail. Beginners tend to just tag each event and hope the parser sorts it out. It does not work. You need an explicit temporal coordinate system. I used a simple integer counter that increments with each player decision. Every action stores its coordinate value. When you render the narrative state, you compare the current coordinate against each stored event coordinate. Events at the current coordinate get present continuous. Events at previous coordinates get past simple. State descriptors that exist across all coordinates stay in simple present. This took me about four hours to implement correctly and maybe six more to debug the edge cases where actions got misordered due to concurrent player input. One counter-intuitive insight that took me months to learn: present continuous is actually the hardest tense to sustain in a simulated timeline. It implies ongoing duration, which means every frame or beat that passes, you have to re-evaluate whether the action is still in progress. If a character is described as "walking down the hall" and five beats pass without them stopping, the continuous form starts to feel wrong. The fix is to introduce duration thresholds. After a set number of beats, automatically promote the continuous action to past simple and either repeat it or drop it depending on context. This mimics how natural language actually behaves under prolonged description.
Get the Full Details
Another thing nobody tells you: past simple has a memory problem. When you accumulate too many completed events in past simple, the narrative becomes a flat list of facts with no sense of urgency or presence. The reader feels like they are reading a report, not experiencing a moment. The solution is a recency window. Only keep the last five to seven events in active past simple. Anything older either transitions into simple present state descriptions or gets dropped entirely. This forces your system to constantly refresh what is narratively relevant rather than letting old actions pile up indefinitely.
Where This Breaks Down
The tense simulation approach collapses completely in systems with branching timelines or flashback mechanics. If your narrative needs to jump around in time, the temporal coordinate system becomes a mess. I tried adding flashback tags that temporarily suspended the coordinate counter, but the prose consistency degraded badly. The tenses would drift out of alignment and you would end up with sentences like "She opened the door and walks into the room" which is just grammatically broken. If your project requires non-linear time, you are better off using a separate narrative layer for time jumps and keeping the tense system linear within each segment. There is also a performance cost. Every render cycle now needs to query the timeline buffer, compare coordinates, and select tenses. For a text adventure with ten actions on screen, this is negligible. For a system generating dozens of concurrent narrative threads in real time, the extra computation adds up. I measured a roughly 30 percent increase in render time with my implementation. If you are working in an environment where response latency matters, you need to cache tense resolutions and only recalculate when the timeline buffer changes. If you need true non-linear time simulation, consider using aspect markers instead of tense markers. Aspect — perfective versus imperfective — handles completion and duration without locking you into a present or past framework. It is less intuitive for writers but far more flexible for system design. A few commercial narrative engines have started adopting this approach with decent results.
Practical Implementation Notes
Start small. Pick a single scene and manually map every sentence to a tense label before you write any code. You will quickly see where the system needs to resolve conflicts. Once you understand the failure modes on paper, the implementation becomes much simpler. I wasted two weeks building features that addressed problems I would have noticed in ten minutes of manual annotation. Use a dedicated tense resolver module rather than scattering the logic across your narrative output functions. A single function that takes an event list and returns properly tensed descriptions keeps your code clean and makes debugging tractable. When something goes wrong, you know exactly where to look. Test with native speakers, not just grammar checkers. The tense simulation approach relies on subtle psychological cues that automated tools do not detect. A sentence can be technically correct and still feel wrong to a human reader. I had a beta tester flag a sequence as "jarring" and it took me three days to realize the issue was that I had used present continuous for an action that had clearly concluded based on contextual clues. The grammar was fine. The timeline logic was not.
The approach is viable for simple to moderately complex narrative systems. It adds structural clarity and reduces the cognitive load on writers who have to manually track when things are happening. But it is not a substitute for good narrative design. No tense system will fix a poorly structured scene. It just makes the timing more visible when the timing is wrong.
