There Was No Way to Manage .NET Localization from the Console, So I Built One

I work primarily in a Linux terminal. SSH into my dev box, tmux sessions, vim, the works. When I started building a .NET WASM application with a .NET API server, I knew I’d need localization support from the start—English and Greek.

That’s when I discovered a glaring gap in the .NET ecosystem: there’s no proper command-line tool for managing .resx localization files.

The Problem: Localization Tooling is GUI-Only

Here’s what’s available for managing .resx files in .NET:

1. Visual Studio - Windows only, GUI only, requires gigabytes of disk space
2. Rider - Another GUI-only IDE
3. VS Code - No decent extension for .resx files
4. ResXResourceManager - Excellent tool, but Windows-only GUI
5. Manual XML editing - Good luck with XML namespaces and encoding

For someone who:

• Develops on a Linux box
• Lives in the terminal
• Works exclusively over SSH
• Needs to add localization to a WASM app

...none of these options work.

The Moment of Realization

I was adding Greek language support to my application. Simple task, right? Add Resources.el.resx, copy the keys from Resources.resx, translate the values.

But how do I actually do this from my terminal?

Option 1: Manual XML editing

vim Resources.el.resx
# Now manually replicate the XML structure
# Copy each <data> element
# Hope you don't mess up the encoding
# Pray you don't introduce XML syntax errors

No. Just no.

Option 2: Write a script

So I wrote a Python script. Then I needed to validate both files. Wrote another script. Then I needed to add a new key to both languages. Modified the script again.

After the third time writing variations of “quick scripts” for basic operations, I realized: this is a fundamental workflow gap.

What I Actually Needed

I wanted a Visual Studio-like experience, but from the command line. Something that could:

• Work entirely in the terminal
• Work over SSH (no GUI)
• Add, update, delete keys across all languages atomically
• Validate completeness and correctness
• Let me edit translations interactively without leaving the terminal
• Be future-proof for when I eventually work with translators

The vision was clear: modern CLI tooling with an interactive TUI, built specifically for .resx management on Linux.

Why This Gap Exists

.NET is genuinely cross-platform now. You can build WASM apps, API servers, microservices—all on Linux with no issues. But the tooling ecosystem is still catching up.

Most .NET localization tools assume:

• You’re on Windows
• You have a GUI available
• You want to use an IDE

But modern development—especially on Linux—is increasingly terminal-first. SSH into a VPS, work in tmux, use terminal tools. It’s faster, cleaner, and works everywhere.

The .NET ecosystem just didn’t have tooling for this workflow.

So I Built LRM

After realizing I’d be writing throwaway scripts forever, I decided to build a proper tool.

Core requirements:

• ✅ Native Linux support (no Mono, no Wine, just .NET)
• ✅ Command-line first (scriptable, automatable)
• ✅ Interactive TUI (Visual Studio-like experience in terminal)
• ✅ Works over SSH (no GUI dependencies)
• ✅ Full CRUD operations (add, update, delete keys)
• ✅ Validation (detect missing keys, duplicates, empty values)
• ✅ Future-proof (CSV import/export for translators)
• ✅ Fast and self-contained (no runtime dependencies)

The result is Localization Resource Manager (LRM)—a modern CLI tool with an interactive Terminal UI for managing .resx files from the command line.

Real Workflow: Adding Greek Support

Before LRM:

# Copy the file
cp Resources.resx Resources.el.resx

# Open in vim and manually translate 200+ strings
vim Resources.el.resx
# Edit XML by hand... for hours

# No way to validate I got everything
# No way to check for consistency
# Pure manual labor

With LRM:

# Add Greek language file
lrm add-language --culture el --copy-from default

# See what needs translation
lrm stats
# ┌──────────────────┬───────┬──────────┐
# │ Language         │ Keys  │ Coverage │
# ├──────────────────┼───────┼──────────┤
# │ English (Default)│ 203   │ 100.0%   │
# │ Ελληνικά (el)    │ 203   │ 100.0%   │ (copied)
# └──────────────────┴───────┴──────────┘

# Edit translations interactively
lrm edit
# [TUI opens, side-by-side view of English/Greek]
# Search, navigate, edit, save
# All from the terminal

# Validate everything is correct
lrm validate
# ✓ All validations passed

This is the workflow I wanted from day one.

The Terminal UI: Visual Studio Experience in SSH

One of my favorite features is the interactive TUI. Run lrm edit and you get a full-featured editor right in your terminal:

┌────────────────────────────────────────────────────────────────┐
│ File  Edit  Languages  Help                                    │
├────────────────────────────────────────────────────────────────┤
│ Search: [save_______________]   Ctrl+N=Add  F2=Language  F6=Val│
├──────────────┬────────────────────────┬────────────────────────┤
│ Key          │ English (Default)      │ Ελληνικά (el)          │
├──────────────┼────────────────────────┼────────────────────────┤
│ SaveButton   │ Save                   │ Αποθήκευση             │
│ CancelButton │ Cancel                 │ Ακύρωση                │
│ DeleteButton │ Delete                 │ Διαγραφή               │
│ ...          │ ...                    │ ...                    │
└──────────────┴────────────────────────┴────────────────────────┘
Keys: 203/203 | Languages: 2                           [MODIFIED]

Features:

• Side-by-side view of all languages
• Real-time search and filtering
• Add/edit/delete keys with full validation
• Manage languages (add/remove with F2/F3)
• Keyboard shortcuts for everything
• Works perfectly over SSH
• Menu bar for discoverability

It’s everything I wanted from Visual Studio, but in the terminal. No GUI needed. No Windows needed. Just solid terminal tooling.

The Command-Line Experience

For scripting and automation, the CLI is comprehensive:

# Validate all .resx files
lrm validate

# Add a new key to both languages
lrm add WelcomeMessage \
--lang default:"Welcome to our app" \
--lang el:"Καλώς ήρθατε στην εφαρμογή μας"

# Update an existing key
lrm update SaveButton \
--lang default:"Save Changes" \
--lang el:"Αποθήκευση Αλλαγών"

# Delete a key from all languages
lrm delete OldFeature

# View a key across all languages
lrm view SaveButton
# Key: SaveButton
# English (Default): Save
# Ελληνικά (el): Αποθήκευση

# Export for translators (future-proofing)
lrm export -o translations.csv

# Import translated work
lrm import updated_translations.csv

# List all languages
lrm list-languages

# Add/remove languages
lrm add-language --culture fr
lrm remove-language --culture de

Every command is designed to work in scripts, CI/CD pipelines, or interactive use.

Future-Proofing: The Translator Workflow

While I’m currently doing all translations myself, I built LRM with the future in mind. When I eventually work with translators, the workflow is ready:

# Export current state to CSV
lrm export --include-status -o for_translator.csv

# Translator edits in Excel/Google Sheets
# (Much easier than editing XML!)

# Import completed translations
lrm import for_translator.csv --overwrite

# Validate everything imported correctly
lrm validate

# Check coverage
lrm stats

This is standard practice for professional localization workflows. LRM makes it trivial.

Why VS Code Extensions Aren’t Enough

Someone might ask: “Why not just use VS Code with an extension?”

I tried. The available .resx extensions are mediocre at best:

• Most just syntax highlight XML
• No side-by-side language comparison
• No validation
• No batch operations
• Still requires a GUI

More importantly: I work primarily in the terminal. SSH sessions, tmux, vim. Opening VS Code just to edit a translation breaks my flow entirely.

LRM fits naturally into a terminal-first workflow.

The Technical Stack

Built with modern .NET:

• .NET 9 for cross-platform support
• Spectre.Console.Cli for CLI framework
• Terminal.Gui for interactive TUI
• Self-contained binaries (no runtime needed)
• Works on x64 and ARM64 (Raspberry Pi included)

Fully cross-platform:

• Linux (x64, ARM64)
• Windows (x64, ARM64)
• Tested on GitHub Actions runners
• Works in Docker containers

The architecture:

LocalizationManager/
├── Core/                   # Parsing, validation, models
├── Commands/               # CLI commands (validate, add, update, etc.)
├── UI/                     # Terminal.Gui TUI editor
└── Tests/                  # Comprehensive test suite

Everything is open source and well-documented.

Why This Matters for Linux .NET Developers

.NET on Linux is real. I’m building production WASM apps with .NET API backends, entirely on Linux. Many developers are doing the same.

But the tooling ecosystem still assumes Windows + Visual Studio for many tasks. Localization is just one example.

If you’re:

• Building .NET apps on Linux
• Working primarily in the terminal
• Using SSH for development
• Running .NET in Docker/Kubernetes
• Tired of “just use Visual Studio” answers

...you’ve probably hit these same walls.

LRM is proof that we can have first-class terminal tooling for .NET development on Linux. We don’t need to compromise.

Open Source and Community-Driven

LRM is completely open source under the MIT license:

🔗 github.com/nickprotop/LocalizationManager

Quick start on Linux:

# One-line install
curl -sSL https://raw.githubusercontent.com/nickprotop/LocalizationManager/main/install-lrm.sh | bash

# Or download manually
wget https://github.com/nickprotop/LocalizationManager/releases/latest/download/lrm-linux-x64.tar.gz
tar -xzf lrm-linux-x64.tar.gz
sudo cp linux-x64/lrm /usr/local/bin/

# Start using it
cd YourProject/Resources
lrm validate
lrm edit

Documentation:

• Installation Guide
• Command Reference
• Usage Examples
• CI/CD Integration

Try It Out

If you:

• Develop .NET apps on Linux
• Work primarily in the terminal
• Need to manage localization
• Want proper CLI tooling instead of GUI-only solutions

Give LRM a try. It’s the tool I wished existed when I started building my WASM app.

Contributions, bug reports, and feature requests are welcome. This is a tool built to solve real problems for real developers working on Linux.

---

Links:

• 📦 GitHub Repository
• 📖 Documentation
• 🐛 Report Issues
• 💬 Discussions
• ⬇️ Download

---

Do you develop .NET on Linux? What tooling gaps have you encountered? Let me know in the comments or open a discussion on GitHub. Let’s make .NET on Linux a first-class experience.