Why does it stop at 3999?

The classical Roman system has no symbol for 5000 or higher, and the conventional limit is 3999 (MMMCMXCIX). Vinculum notation for larger numbers is uncommon and not implemented.

Are lowercase numerals accepted?

Yes. Input is normalised to uppercase before parsing, so iv and IV both convert to 4.

Is my input sent to a server?

No. Conversion happens in the browser.

How strictly is the notation validated?

Only standard forms are accepted. Repeated subtractives (IIV), forbidden repeats (VV, LL, DD), and out-of-order symbols (IL, IC) all return an error rather than guessing the intent.

decimal ↔ roman · I V X L C D M · 1-3999 · live

Convert Roman numerals

Translate decimal numbers (1 to 3999) into Roman numerals and back. Subtractive notation is used — IV, IX, XL, XC, CD, CM.

Roman ↔ Decimal

Input

4 B

1 lines

Output

7 B

1 lines

Status

ready

live

Ratio

1.75×

out/in

input · decimal

output · roman

MCMXCIV

Quick Start

How the conversion works

To Roman: greedy match the largest symbol whose value fits, subtract, repeat. From Roman: read left to right; subtract when a smaller symbol precedes a larger one (IV → 4), otherwise add.

01
Pick a direction
Decimal → Roman or Roman → Decimal.
Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.
modestricttolerantliveparse
dir · sourceset · live
```
Decimal → Roman
```
loaded · parsedtarget · ready
02
Type your value
Decimals 1 to 3999, or Roman characters I V X L C D M.
Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.
inputtype-preservinglosslesslivememoised
in · optionsvalue · live
```
1994
```
options applied · liveround-trip
03
Greedy match
Largest fitting symbol is taken and subtracted: 1994 → M(1000) + CM(900) + XC(90) + IV(4).
Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.
mathidempotentround-tripdiff-cleandeterministic
step · convertedby step · ready
```
1994 → MCMXCIV
```
converted · livediff-clean
04
Copy result
One-click copy. Errors surface for inputs outside 1-3999 or with invalid characters.
Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.
exportclipboardtarget MIMEblobclient-side
✓ · copiedready · done
```
✓ Copied
```
shipped · ready to shipsuccess

Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Use Cases

When to convert Roman numerals

Pagination, copyright, naming.

Book front matter

Prefaces and introductions traditionally use Roman numbering. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Movie sequels

Sequels number with Roman numerals — III, IV, V. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Pagination

Outline lists with i, ii, iii inside docs. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Section labelling

Generate stable Roman labels for chapter headings. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

Copyright dates

Quickly translate MMXXVI to 2026 for footer credits. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Education

Practice or check schoolwork answers. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade

FAQ

Frequently asked questions

Why not zero or negatives?

Classical Roman numerals have no symbol for zero and don't represent negative numbers. The tool errors on inputs outside 1-3999.

Are lowercase letters accepted?

Yes — they're uppercased before parsing.

What about overline forms?

Overline (a bar denoting multiplication by 1000) isn't supported — the tool tops out at MMMCMXCIX = 3999.

Is subtractive notation used?

Yes — IV (4), IX (9), XL (40), XC (90), CD (400), CM (900) are emitted to keep the output compact.

Is anything sent to a server?

No. Conversion is entirely local.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!