Software stores data the way machines like it. Users want to read it the way humans like it.

So you write this boilerplate code every day.

You manually split a PascalCase enum into words. You turn 2 into "2nd" with a few if statements.

You format a timestamp as "3 hours ago". You pluralize "item" only when the count is not 1.

It is a few lines here, a helper method there - and it piles up across a codebase.

Humanizer is a small, free .NET library that does all of it for you.

It turns developer-shaped data into human-friendly text with a single method call.

In this post, we will explore:

• How to Humanize and transform strings
• How to Humanize enums
• How to Humanize dates and times
• How to Turn numbers into words
• How to Work with culture
• How to Pluralize and quantify
• How to Format byte sizes and large numbers
• Bonus: Roman numerals, collections, and fluent dates

Let's dive in.

First, add Humanizer to your project by installing the following NuGet package:

bash
1dotnet add package Humanizer

The core of Humanizer is Humanize(), which turns a developer string into a readable sentence.

It splits strings in PascalCase, camelCase, snake_case, kebab-case, all in lower or UPPER case, into words and applies sentence casing:

csharp
1"PascalCaseInputStringIsTurnedIntoSentence".Humanize();
2// => "Pascal case input string is turned into sentence"
3
4"Underscored_input_string_is_turned_into_sentence".Humanize();
5// => "Underscored input string is turned into sentence"

Transform changes the casing without splitting words. It takes one or more strategies:

csharp
1"Sentence casing".Transform(To.TitleCase);    // => "Sentence Casing"
2"Sentence casing".Transform(To.LowerCase);    // => "sentence casing"
3"Sentence casing".Transform(To.SentenceCase); // => "Sentence casing"

Dehumanize is the reverse of Humanize - it turns a sentence back into a PascalCase identifier:

csharp
1"Pascal case input string is turned into sentence".Dehumanize();
2// => "PascalCaseInputStringIsTurnedIntoSentence"

And Truncate shortens text to a length, adding an ellipsis:

csharp
1"Long text to truncate".Truncate(10);
2// => "Long text…"

These four cover most of the string formatting you write by hand: generating labels, display names, and identifiers from code.

Enum names are in PascalCase, and your UI needs readable labels.

Normally, you map each enum member to a label by hand:

csharp
1var label = status switch
2{
3    ShipmentStatus.OutForDelivery => "Out for delivery",
4    ShipmentStatus.InTransit => "In transit",
5    // ... a line for every member
6};

Calling Humanize() on the enum value does the same thing for free. It splits the name into words, so the switch disappears:

csharp
1public enum ShipmentStatus
2{
3    Pending,
4    InTransit,
5    OutForDelivery,
6    Delivered
7}
8
9ShipmentStatus.OutForDelivery.Humanize();  // => "Out for delivery"
10ShipmentStatus.InTransit.Humanize();       // => "In transit"

When you need a label that does not match the member name, add a [Description] attribute and Humanizer uses it:

csharp
1public enum ShipmentStatus
2{
3    [Description("Awaiting pickup")]
4    Pending,
5    // ...
6}
7
8ShipmentStatus.Pending.Humanize();  // => "Awaiting pickup"

You can also go the other way, turning a display string back into the enum value with DehumanizeTo:

csharp
1"Out for delivery".DehumanizeTo<ShipmentStatus>();
2// => ShipmentStatus.OutForDelivery

This alone removes a surprising amount of mapping code from the boundary between your domain and your UI.

"2 hours ago" reads better than a raw timestamp. Humanizer produces it from a DateTime:

csharp
1DateTime.UtcNow.AddHours(-2).Humanize();
2// => "2 hours ago"
3
4DateTimeOffset.UtcNow.AddHours(1).Humanize();
5// => "an hour from now"

It compares the date to now and describes the difference in plain language - the relative timestamps you see on every social feed and dashboard.

TimeSpan works the same way, and a precision argument controls how many units it shows:

csharp
1TimeSpan.FromDays(1).Humanize();
2// => "1 day"
3
4TimeSpan.FromDays(16).Humanize(precision: 2);
5// => "2 weeks, 2 days"

So a shipment's estimated delivery window or a job's run time becomes readable without date math on your end.

Sometimes a number needs to be spelled out - on an invoice, a cheque, or a generated document.

ToWords does exactly that:

csharp
13501.ToWords();
2// => "three thousand five hundred and one"

For positions rather than amounts, Ordinalize adds the suffix and ToOrdinalWords spells it out:

csharp
11.Ordinalize();   // => "1st"
25.Ordinalize();   // => "5th"
321.Ordinalize();  // => "21st"
4
51.ToOrdinalWords();  // => "first"
62.ToOrdinalWords();  // => "second"

Getting "1st", "2nd", "3rd", and "21st" right by hand is fiddly - the rules have exceptions. Humanizer knows them.

Humanizer is culture-aware. It ships with localizations for dozens of languages, so date humanization, ToWords, and number formatting follow the current culture.

When you need a specific culture, pass a CultureInfo explicitly:

csharp
1using System.Globalization;
2
3var culture = CultureInfo.GetCultureInfo("es");
4
5DateTime.UtcNow.AddHours(-2).Humanize(culture: culture);
6// => "hace 2 horas"
7
83501.ToWords(culture: culture);
9// => "tres mil quinientos uno"

If you only need neutral English resources, you can install the smaller Humanizer.Core package. For other languages, install the matching Humanizer language package.

Grammar around counts is full of edge cases: "1 item" but "2 items"; "1 person" but "2 people".

Pluralize and Singularize handle the irregular forms English is famous for:

csharp
1"Man".Pluralize();    // => "Men"
2"Men".Singularize();  // => "Man"

Without ToQuantity, you end up writing the familiar ternary by hand:

csharp
1var text = $"{count} {(count == 1 ? "case" : "cases")}";

ToQuantity is the one you will reach for most. Give it a number, and it both pluralizes the word and prefixes the count:

csharp
1"case".ToQuantity(0);  // => "0 cases"
2"case".ToQuantity(1);  // => "1 case"
3"case".ToQuantity(5);  // => "5 cases"

Ask for the number as words, and it spells out the count too:

csharp
1"case".ToQuantity(5, ShowQuantityAs.Words);
2// => "five cases"

This is the clean replacement for the count == 1 ? "item" : "items" ternaries scattered across your views.

File sizes and big counts have their own human formatting, and Humanizer covers both.

Its byte-size helpers turn a raw number into the right unit:

csharp
1(10).Kilobytes().Humanize();    // => "10 KB"
2(0.5).Kilobytes().Humanize();   // => "512 B"
3(1024).Kilobytes().Humanize();  // => "1 MB"

For large counts, ToMetric produces the compact "k / M / B" form you see on dashboards and social buttons:

csharp
11230d.ToMetric();      // => "1.23k"
2"1.23k".FromMetric();  // => 1230

Display a download size or a follower count without writing your own unit-scaling logic.

Roman numerals convert both ways:

csharp
12024.ToRoman();     // => "MMXXIV"
2"XIV".FromRoman();  // => 14

A collection of strings becomes a readable list - the items separated by commas, with the last joined by "and":

csharp
1var carriers = new[] { "FedEx", "UPS", "DHL" };
2
3carriers.Humanize();
4// => "FedEx, UPS and DHL"

And the fluent date API builds TimeSpan and DateTime values that read like English:

csharp
1var dueDate = 2.Days().FromNow();   // the DateTime two days from now
2var window  = 2.Days() + 3.Hours(); // a TimeSpan of 2 days and 3 hours

None of these are things you reach for daily, but when you need them, each one saves you a helper class.

Humanizer is a small dependency that removes an entire category of code you would otherwise write and maintain by hand.

Let's recap the key takeaways:

• Readable text from code shapes. Humanize, Transform, and Dehumanize convert PascalCase strings and enum members into display labels and back.
• Human-friendly dates and numbers. DateTime.Humanize() gives you "2 hours ago", TimeSpan.Humanize() reads timespans in plain words, and ToWords and Ordinalize spell numbers out.
• Correct grammar around counts. Pluralize, Singularize, and ToQuantity handle irregular plurals and the "1 item vs 2 items" problem for you.
• Sizes and big numbers. The byte-size helpers and ToMetric format file sizes and large counts the way users expect.

None of this is hard to write yourself (because of edge cases).

The point is that you should not have to - it is a solved problem, the rules have edge cases, and Humanizer has them covered.

Reach for it the next time you find yourself formatting data for a human to read.

Hope you find this newsletter useful. See you next time.