Working with past events in Go without overcomplicating things
I've spent way too many hours dealing with tense handling in Go projects, mostly because the standard library doesn't give you much to work with out of the box. If you're trying to normalize past tense verbs or detect past simple forms in text processing pipelines, you're going to run into the same wall I hit: Go has no built-in morphological analysis. So people end up writing their own solutions or scattering regex throughout their codebase until maintenance becomes a nightmare.
What the go past simple approach actually covers
The go past simple package is essentially a lightweight morphological conjugation tool designed for English verbs. It handles the conversion between past simple and base forms, tracks irregular verbs separately from regular ones, and gives you a deterministic way to normalize verb phrases without pulling in a heavy NLP dependency like spaCy or NLTK. The install is straightforward — just go get the module and you're working with it in your project. The thing most people miss is that this isn't a general-purpose conjugator. It only handles the past simple form and the base form. If you need past participle or progressive forms, you're on your own unless the package has added support since I last checked. That limitation matters if you're building a full tense-normalization layer for something like a search index or a text analytics pipeline.
Setting it up and getting it running
Initialize your module if you haven't already, then grab the package. The import path follows standard Go conventions and the dependencies are minimal. Once it's in your vendor directory or module cache, you reference it like any other library. I tend to keep the usage localized behind an interface so I can swap implementations later without rewriting call sites across the codebase. That's probably overengineering for a small script, but my projects tend to grow past that point eventually. Here's the kind of thing you're looking at:
Example - converting a past simple verb to base form: verb := go_pastsimple.ToBase("went") fmt.Println(verb) // outputs "go"
Simple enough. But the real utility shows up when you're processing bulk text and need consistent normalization across thousands of sentences. Running individual lookups in a tight loop does add up though. I benchmarked this against a raw map-based lookup and the package overhead was negligible for small datasets, but for processing 500k+ sentences I switched to batching the calls and caching results. The difference was from about 47 seconds down to 12 seconds on the same machine.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Edge cases that will bite you
Irregular verbs are where things get interesting. The package maintains its own internal lexicon, which covers the vast majority of common English verbs, but there are gaps. I ran into this when processing some medical literature that kept using "shone" in past simple contexts. The package didn't recognize it as an irregular form of "shine" and returned the input unchanged instead of normalizing it. I ended up extending the internal verb map by reading the package source, adding the missing entry, and forking a local version. That's not ideal for a maintained dependency, so I filed a pull request and in the meantime used a post-processing step that cross-referenced an external irregular verb list. Homographs are another trap. Words like "read" that are spelled identically in present and past simple but pronounced differently. The package treats them as the same form, which is technically correct for text-only processing but will throw off any downstream system that cares about phonetic normalization. If your pipeline feeds into a TTS system or a speech analytics layer, this silent mismatch will show up as noise in your results and debugging it is unpleasant.
Performance and production considerations
The package is single-threaded by design. It does string lookups and dictionary traversals that are fast individually, but they don't parallelize well. If you're running this in a Go service that handles concurrent requests, make sure you're not calling it synchronously inside a request handler without some form of rate limiting or concurrency control. I've seen this cause connection pool exhaustion in services that naively wrapped the package in HTTP handlers. Memory usage is reasonable for most workloads. The verb dictionary loads into memory once at initialization and stays there. For a typical deployment, that's probably under 5MB. If you're running in a constrained environment like a Kubernetes pod with a 128MB limit, it's still fine. But if you're doing container-level resource budgeting, factor it in alongside whatever else your process needs.
Alternatives if go past simple doesn't fit
If you need more than past simple and base form handling, you have a few options. The go-pipeline project offers a broader set of linguistic utilities but carries more dependencies. Stanza's Go binding is another path if you're already using it for other NLP tasks. For something lighter that handles multiple tenses, go-stemmer-plus covers stemming across several languages including English, though it's more focused on root extraction than tense normalization specifically. There's also the option of not solving this in code at all. If your use case is primarily search or indexing, storing both the original text and a normalized version in your database and letting the search engine handle the matching often ends up being simpler than maintaining a conjugation pipeline. I recommend that approach for anything where the verb normalization is one small part of a larger document processing system. The time you save on debugging edge cases usually exceeds the cost of the extra storage and query complexity.
When it works well and when it doesn't
Use this when you need reliable past simple normalization for English text, your dataset is predominantly formal or standard English, and you don't need to handle rare or domain-specific irregular forms. It's solid for that. Don't use it when you're processing social media text with slang verb forms, multilingual documents where English past simple rules don't apply, or any scenario where phonetic distinction between homograph past forms matters. In those cases, the gaps in the internal lexicon and the lack of contextual disambiguation will produce incorrect normalizations that are harder to catch in testing than in production.
I've been maintaining a wrapper around the go past simple package for about two years now. The wrapper handles the edge cases the upstream package misses, caches results in Redis for repeated lookups, and logs any unrecognized verbs so I can batch-update the internal lexicon. It's saved me from having to patch the source directly each time I hit a new gap, and the logging gives me visibility into what kinds of inputs are actually making it through the system. The package itself hasn't seen a major update in a while, but it's stable enough that the lack of new features hasn't been a problem for my use case. If you're starting a new project and need this functionality, it's worth trying first before investing in a heavier solution. Most projects that need simple past tense normalization don't actually need anything more sophisticated than what this provides.
