I write for a living in two different ways. Some days I'm in a Laravel controller or a React component naming variables; other days I'm writing docs for the WP Adminify plugin or a blog post like this one. Both jobs are text manipulation, and both used to be littered with tiny friction — renaming a variable from one convention to another, checking whether a paragraph fit a character limit, diffing two config files to find the one line that broke a deploy.
For years I solved those the slow way: a throwaway Node script here, a browser tab of some ad-choked utility site there, a wc -w in the terminal when I couldn't be bothered. The tab-of-some-utility-site option is the one that eventually pushed me to build toolz.dev. Half of those sites uploaded your text to a server for a job the browser can do locally, and I didn't love pasting client contracts into a stranger's backend to count the words.
This guide is the set of text tools I actually reach for, and how I use them. Every one runs entirely in your browser — the text never leaves your machine — and none of them need an account. Whether the work is code, copy, or config, the right small tool turns a two-minute chore into a two-second one.
TL;DR: For code, Case Converter switches between camelCase, snake_case, kebab-case and 7 more formats. For writing, Word Counter gives words, characters, sentences and reading time live. For reviewing changes, Text Diff highlights what moved between two versions. For mockups, Lorem Ipsum fills layouts, and Slug Generator turns titles into clean URLs. All client-side, all free.
Why Use a Dedicated Text Tool Instead of Your Editor?
Your editor is great at the thing it's built for and clumsy at everything adjacent. VS Code will happily let you write a variable, but ask it to convert forty snake_case column names into camelCase and you're writing a regex or a multi-cursor dance that goes wrong on the one name with a number in it. Google Docs counts words, but it won't tell you a caption is 12 characters over the Instagram cutoff, and it definitely won't diff two versions of a YAML file the way you need.
Specialized text tools fill those gaps. They do one job, expose exactly the options that job needs, and get out of the way. The three that earn permanent bookmarks for me are case conversion, counting, and diffing — everything else is situational. The rest of this guide walks through each, in the order I use them most.
A quick note on privacy, because it's the whole reason toolz.dev exists as a browser-first project: every tool here processes text with JavaScript in your own tab. There's no upload step, no server round-trip, no log of what you pasted. That matters when the "text" is an unpublished manuscript, a signed contract, or a .env file you were only supposed to be debugging.
How Do You Convert Text Between camelCase, snake_case and Other Formats?
Case conversion is the single text task I do most as a developer, and it's the one editors handle worst. Different languages expect different conventions, and mixing them is a code smell any reviewer will flag: JavaScript wants camelCase for variables and PascalCase for React components, Python wants snake_case, CSS wants kebab-case, and constants everywhere want SCREAMING_SNAKE_CASE.
The Case Converter detects word boundaries from whatever you paste — spaces, underscores, hyphens, or the humps in camelCase — and re-emits them in the format you pick. The formats it covers and where each one belongs:
- camelCase —
getUserProfile. JavaScript/TypeScript/Java variables and functions. - PascalCase —
UserProfile. Classes, TypeScript interfaces, React and Vue components. - snake_case —
get_user_profile. Python, Ruby, Rust, and SQL columns. - SCREAMING_SNAKE_CASE —
MAX_RETRY_COUNT. Constants and environment variables in every language. - kebab-case —
user-profile. CSS classes, URL slugs, npm packages, Kubernetes labels. - Title Case —
The Quick Brown Fox. Headlines and titles. - Sentence case —
The quick brown fox. Body text and UI labels. - dot.case —
user.profile.settings. Java packages, config keys, object paths.
The part that saves real time is that it converts multi-line input line by line. Copy a whole block of database column names, paste it, pick camelCase, and every line comes out as the matching application variable. I do that so often when wiring a Laravel model to a React form that it's muscle memory now.
For the full breakdown of every format, the language-by-language table, and the acronym-handling traps that catch automated converters, I wrote a dedicated companion: the Text Case Converter guide.
How Do You Count Words and Characters Accurately?
Counting looks trivial until you hit the edge cases. "Split on spaces and count" breaks on double spaces, hyphenated compounds, contractions, and URLs. The Word Counter handles those and reports the full set of metrics live as you type: word count, characters with spaces, characters without spaces, sentence count, paragraph count, and estimated reading time.
The metric you need depends entirely on the platform, and the limits are worth knowing by heart:
| Platform / context | Limit | Metric that matters |
|---|---|---|
| Twitter / X post | 280 | Characters (URLs count as 23) |
| Instagram caption | 2,200 | Characters (125 visible before "more") |
| LinkedIn post | 3,000 | Characters (~210 before "see more") |
| SMS segment | 160 | Characters |
| SEO meta description | ~155 | Characters |
| SEO title tag | ~60 | Characters |
| Google Ads headline | 30 | Characters |
| Common App essay | 650 | Words |
Word count is the metric for essays, articles, and per-word freelance invoicing. Character count is the metric for anything with a hard field limit. The reading-time estimate divides your word total by an average silent reading speed of roughly 200–250 words per minute, which is close enough for the "5 min read" label on a blog and, at the 130–150 WPM speaking rate, close enough to size a conference talk.
The deeper dive — how the counting algorithm handles the tricky cases, and the word-count targets I aim for by content type — is in the Word Counter guide.
How Do You Compare Two Versions of Text?
Diffing is the tool I underrate right up until the moment it saves a deploy. When a service that worked yesterday breaks today and the only thing that changed is "some config," the fastest path to the culprit is pasting the working version and the broken version side by side and letting the diff point at the one line that moved.
The Text Diff tool takes two blocks of text and highlights additions, deletions, and changes. Beyond config debugging, I use it for:
- Contract and proposal review — spot exactly what the other party edited between draft three and draft four.
- Content revisions — see what an editor actually changed in a post rather than re-reading the whole thing.
- Copy-paste sanity checks — confirm two supposedly-identical snippets really are identical.
Here's the admitted mistake that taught me to trust the tool over my eyes. Early on with toolz.dev I "fixed" a broken environment file by comparing it to the working one visually, decided the two looked the same, and went hunting for the bug elsewhere for the better part of an hour. When I finally dropped both into a diff, the difference was a single trailing space after a value — invisible to me, very visible to the parser. A terminal git diff would have shown it too, but the point stands: whitespace and near-identical lines are exactly what human eyes skip and a diff never does.
When Should You Use Lorem Ipsum vs Real Placeholder Text?
Placeholder text exists so you can judge a layout without getting distracted by reading the words. Lorem Ipsum — the scrambled Latin from Cicero's De Finibus Bonorum et Malorum that typesetters have used since the 1500s — works because it has the rhythm of real language without meaning anything. Your eye evaluates the shape of the paragraph instead of parsing sentences.
The Lorem Ipsum generator produces paragraphs, sentences, or a specific word count, with the option to open on the traditional "Lorem ipsum dolor sit amet." I lean on it whenever I'm building a UI component in React and need body text that behaves like content — wraps, overflows, breaks across lines — before the real copy exists.
The one habit worth keeping: generate placeholder at the length of your real content, not two throwaway words. A card designed around "Lorem ipsum" and then filled with a 60-word description will blow out its layout the moment real text arrives. Match the volume and your mockup tells you the truth.
What Other Text Tools Are Worth Bookmarking?
A handful of smaller utilities round out the set:
- Slug Generator — turns "How to Convert Text Case Online" into
how-to-convert-text-case-online, lowercasing, stripping punctuation, and replacing spaces with hyphens. Essential for URL-friendly blog paths and any CMS that doesn't slugify cleanly. - String Reverse — reverses character order. Niche, but genuinely useful for palindrome checks and for testing how your code handles multi-byte characters and emoji.
- Base64 Converter — encodes and decodes Base64, which shows up everywhere from data URLs to HTTP Basic Auth to the payload of a JWT.
- UUID Generator — creates universally unique identifiers for database rows, test fixtures, and distributed systems that can't rely on sequential IDs.
- Timestamp Converter — moves between Unix timestamps, ISO 8601, and human-readable dates, which I need constantly when reading logs.
Each is a single-purpose tool that does its one job and nothing else — the whole philosophy behind the site.
A Practical Workflow: From Draft to Published
These tools chain together better than they work alone. The loop I run for almost every piece of writing, including toolz.dev's own content:
- Draft in a real editor, ignoring length entirely on the first pass.
- Check length in the Word Counter and trim the sections that ran long relative to their importance.
- Diff against the previous version in Text Diff so I can see exactly what an edit changed before I commit it.
- Generate the URL slug with the Slug Generator.
- Convert any headline casing with the Case Converter.
For code, the loop is shorter: paste identifiers into the Case Converter to match the language I'm writing in, and diff before-and-after when a refactor touched more lines than I expected. None of it requires switching away from the tab, and none of it uploads a byte.
Frequently Asked Questions
What are the best free online text tools?
It depends on the job. For converting between naming conventions, the Case Converter handles 10-plus formats. For length checks, the Word Counter reports words, characters, sentences and reading time. For reviewing edits, the Text Diff highlights changes. All three are free, need no signup, and run entirely in your browser.
Are online text tools safe for sensitive documents?
The tools on toolz.dev are, because they process everything client-side — your text is handled by JavaScript in your own tab and never sent to a server. That's not true of every online text tool; many upload your input for processing. If a tool doesn't clearly state it runs locally, assume your text reaches its backend and avoid it for contracts, unpublished work, or anything confidential.
How do I convert text case online?
Open the Case Converter, paste your text in any format, and pick the target — camelCase, snake_case, kebab-case, PascalCase, Title Case, and more. The result appears instantly and copies with one click. It detects word boundaries automatically, so you can convert from any format to any other.
How do I count words and characters at the same time?
Paste your text into the Word Counter. It shows word count, character count with and without spaces, sentence count, paragraph count, and estimated reading time simultaneously, updating live as you edit. It works with any space-separated language.
How do I compare two texts to find the differences?
Use the Text Diff tool. Paste the original into one panel and the modified version into the other; the tool highlights additions, deletions, and changes so you can see precisely what moved. It catches near-identical lines and stray whitespace that the eye tends to skip.
Do these text tools work offline?
Yes, once the page has loaded. Because the processing happens in your browser rather than on a server, the tools keep working if your connection drops. Load the tool page while you're online and you can convert, count, and diff without any network access.
Is there a limit on how much text I can process?
There's no artificial cap — the practical limit is your device's memory, since everything runs locally. For normal documents, code files, and social posts you'll never come close to it. Extremely large inputs (many megabytes of text at once) may feel slow because your browser is doing all the work, but that's a performance ceiling, not a usage limit.
Why does my word count differ between tools?
Because "word" isn't defined the same way everywhere. Tools disagree on whether a hyphenated compound is one word or two, whether standalone numbers count, and how they treat em dashes with no surrounding spaces. Microsoft Word, Google Docs, and online counters can land within a percent or two of each other on the same text. If a hard limit matters — a journal submission, an ad field, a school assignment — count with the same tool the person checking it will use.
How many words is a 5-minute read?
Roughly 1,000 to 1,250 words, using the 200–250 words-per-minute range that most reading-time estimates assume. The Word Counter reports reading time alongside the word count, so you can see the estimate update as you write. Treat it as a rough guide: dense technical prose reads far slower than a conversational blog post of the same length.
How do I turn a title into a URL slug?
Paste it into the Slug Generator. It lowercases the text, replaces spaces with hyphens, strips punctuation and accents, and drops anything that isn't URL-safe — so "The Developer's Guide: Text Tools!" becomes the-developers-guide-text-tools. Doing this by hand is where stray apostrophes and double hyphens sneak into URLs.
Conclusion
Text work is constant and invisible — a hundred small transformations a day that you barely notice until each one costs thirty seconds it shouldn't. Converting a variable name, checking a caption length, finding the one changed line in a config: none of it deserves a context switch or a trip to a server.
The text tools on toolz.dev are the ones I built and use because the browser can do all of it locally, instantly, and privately. Bookmark the two or three you touch most, and the friction just disappears.
Start here:
- Case Converter — switch between 10-plus naming conventions
- Word Counter — words, characters, sentences, reading time
- Text Diff — compare two versions and see what changed
- Lorem Ipsum — generate placeholder text for layouts
- Slug Generator — turn titles into clean URLs
- Base64 Converter — encode and decode Base64
Related reading:
