avro-phonetic-go: Avro-style Banglish to বাংলা transliteration in Go

Mehedi Hasan Sajib — Mon, 29 Dec 2025 21:23:45 +0000

If you work with Bengali users, you already know the problem.

People type Bangla using Latin letters. Not carefully. Not consistently.
Yet they expect your application to understand them.

The Avro Phonetic keyboard showed that this problem can be solved using
a grammar-driven approach: pattern matching combined with local context rules.

This article introduces avro-phonetic-go, a Go library that implements
an Avro-style phonetic transliteration engine with a clean, production-oriented API.

Design goals

The library was built with the following principles:

Grammar-driven, not hardcoded
Deterministic output using longest-match scanning
Explicit rule evaluation (prefix and suffix constraints)
No magic heuristics in strict mode
Optional BD mode for modern Bangladeshi typing shortcuts

The overall idea is credited to the Avro Phonetic keyboard.
The internal design of this library was strongly influenced by
the PHP reference implementation https://github.com/imerfanahmed/avro-php

Quick example

Strict mode:

fmt.Println(avrophonetic.To("ami bangla gan gai"))
// আমি বাংলা গান গাই

BD mode (opt-in):

fmt.Println(avrophonetic.ToBD("tmi valo"))
// তুমি ভালো

How it works

At a high level, the engine works in four steps:

Load a grammar consisting of patterns and rules
Build a trie for fast longest-match lookup
Scan the input left to right
Validate candidate patterns using local context rules

Rules are evaluated only against immediate neighbors.
There is no backtracking, which keeps the algorithm predictable and fast.

Strict mode vs BD mode

Strict mode is intended to behave as a clean Avro-style baseline.
If you want exact behavior, use strict mode only.

BD mode layers a small set of additional patterns on top of strict grammar.
These patterns capture real-world Bangladeshi typing habits
without polluting the base grammar.

This separation keeps the engine usable for both compatibility
and user-experience–oriented applications.

Custom grammar support

The engine is fully grammar-driven.

You can load a complete grammar JSON file to reach parity with the grammar you prefer:

g, _ := avrophonetic.FromGrammarFile("grammar.json")
a := avrophonetic.New(avrophonetic.WithGrammar(g))
fmt.Println(a.Parse("ami"))

This makes the library suitable for search indexing, chat processing,
form normalization, and NLP pipelines.

Credits

Avro Phonetic keyboard: original idea and grammar concept
PHP reference implementation: https://github.com/imerfanahmed/avro-php

This project is an independent Go implementation and is not affiliated with the original Avro project.

Closing thoughts

Transliteration is a small feature with outsized impact.

If your product handles Bengali user input,
doing this well is not optional anymore.

Repository: https://github.com/mhshajib/avro-phonetic-go
Documentation and examples are available in the README.

Generate Legacy .xls Files in Go Without LibreOffice — Introducing RetroXL

Mehedi Hasan Sajib — Sun, 30 Nov 2025 23:59:19 +0000

Generate Legacy `.xls` Files in Go Without LibreOffice — Introducing RetroXL

Many banks, government portals, and older enterprise systems still require uploads in the legacy .xls Excel format. Go makes it easy to generate modern .xlsx files, but generating real .xls content usually requires installing LibreOffice, Python scripts, COM automation, or external system binaries.

This approach is slow, hard to deploy, and unsuitable for containers or microservice workflows.

To solve this problem, I built RetroXL, a pure-Go library that generates legacy-compatible .xls files from .xlsx, .csv, .tsv, or in-memory data structures.

Repository: https://github.com/mhshajib/retroxl

The Real Problem

If you work with banking integrations, you may have faced this issue:

Some bank portal rejects .xlsx
Some bank only accepts .xls
The validation rules are strict
The older systems cannot parse modern formats

Most Go libraries output .xlsx. Meanwhile, generating .xls typically requires tools that are heavy, slow, and not ideal for production deployments.

RetroXL addresses this directly.

What RetroXL Does

RetroXL generates .xls files using the SpreadsheetML 2003 (XML) format accepted by Excel as a valid .xls.

Key characteristics:

Pure Go implementation
Zero external dependencies or binaries
Converts .xlsx to .xls
Converts .csv and .tsv to .xls
Builds .xls from in-memory slices or tables
Outputs to file, bytes, or any io.Writer
Works over HTTP, gRPC, S3, etc.

Installation

go get github.com/mhshajib/retroxl

Example 1: Convert `.xlsx` to `.xls`

package main

import (
    "log"
    "github.com/mhshajib/retroxl"
)

func main() {
    err := retroxl.ConvertXLSXToXLSFile("input.xlsx", "output.xls")
    if err != nil {
        log.Fatalf("convert failed: %v", err)
    }
}

Example 2: Generate `.xls` from a slice of structs

package main

import (
    "github.com/mhshajib/retroxl"
)

type Payment struct {
    AccountNo string
    Amount    float64
    Reference string
}

func main() {
    items := []Payment{
        {"1234567890", 1200.50, "Invoice-001"},
        {"9876543210", 300.00,  "Invoice-002"},
    }

    headers := []string{"AccountNo", "Amount", "Reference"}

    var rows [][]any
    for _, p := range items {
        rows = append(rows, []any{p.AccountNo, p.Amount, p.Reference})
    }

    sheet := retroxl.FromRows("BankUpload", headers, rows)
    _ = retroxl.WriteXLSFile("bank_upload.xls", []retroxl.Sheet{sheet})
}

Example 2: Generate `.xls` from a slice without structs

package main

import (
    "github.com/mhshajib/retroxl"
)

func main() {
    headers := []string{"AccountNo", "Amount", "Reference"}
    rows := [][]any{
        {"1234567890", 1200.50, "Invoice-001"},
        {"9876543210", 300.00,  "Invoice-002"},
    }

    sheet := retroxl.FromRows("BankUpload", headers, rows)
    _ = retroxl.WriteXLSFile("bank_upload.xls", []retroxl.Sheet{sheet})
}

Example 3: Stream `.xls` over HTTP

func handler(w http.ResponseWriter, r *http.Request) {
    headers := []string{"AccountNo", "Amount"}
    rows := [][]any{{"123", 100}, {"456", 200}}

    sheet := retroxl.FromRows("Demo", headers, rows)

    w.Header().Set("Content-Type", "application/vnd.ms-excel")
    w.Header().Set("Content-Disposition", `attachment; filename="demo.xls"`)

    _ = retroxl.WriteXLSWriter(w, []retroxl.Sheet{sheet})
}

When To Use RetroXL

Use RetroXL when:

A bank or government portal only accepts .xls
Your Go app generates .xlsx or .csv
You want a container-friendly, dependency-free solution
You need direct streaming over HTTP, gRPC, or cloud storage

Avoid RetroXL if you need:

Complex styling
Formulas or pivot tables
BIFF8 binary (.xls) output

Conclusion

RetroXL provides a clean, dependency-free way to generate legacy .xls files directly from Go. If your workflows involve banking portals, finance systems, or older enterprise applications, RetroXL removes the complexity of external conversion tools.

Repository:

https://github.com/mhshajib/retroxl

Feedback and contributions are welcome.

DEV Community: Mehedi Hasan Sajib

avro-phonetic-go: Avro-style Banglish to বাংলা transliteration in Go

Design goals

Quick example

How it works

Strict mode vs BD mode

Custom grammar support

Credits

Closing thoughts

Generate Legacy .xls Files in Go Without LibreOffice — Introducing RetroXL

Generate Legacy .xls Files in Go Without LibreOffice — Introducing RetroXL

The Real Problem

What RetroXL Does

Installation

Example 1: Convert .xlsx to .xls

Example 2: Generate .xls from a slice of structs

Example 2: Generate .xls from a slice without structs

Example 3: Stream .xls over HTTP

When To Use RetroXL

Conclusion

Generate Legacy `.xls` Files in Go Without LibreOffice — Introducing RetroXL

Example 1: Convert `.xlsx` to `.xls`

Example 2: Generate `.xls` from a slice of structs

Example 2: Generate `.xls` from a slice without structs

Example 3: Stream `.xls` over HTTP