Blog

Number Counter: Types, Code, and How to Build One

A number counter is any tool or component that increments a value. It could be an online tally clicker, an animated count-up stat on a website, or a dynamic number in slides and video. Pick your platform, then set the target value, duration, and easing.

What Is a Number Counter? Definition and Core Mechanics

A number counter is any tool or component that increments a value. It could be a tally clicker in a browser tab, an animated count-up statistic on a page, or a dynamic number in slides and video. The thing they share is the increment itself, not the medium. That’s why a physical clicker and a JavaScript count-up are in the same category.

Since a counter is defined by the increment rather than the platform, the same basic idea works across very different outputs. Every number counter—whether it’s a click tool or a web animation—is built from six parts: start value, target value, step (usually 1), duration, easing, and trigger.

Most use cases fall into five families. Tally or click counters add one event per tap. Animated web stat counters reveal a fixed figure on a page. Character counters measure text as you type. Slide and video counters animate a number inside a deck or rendered clip. Live data clocks count continuously against a changing source, not toward a fixed target. A live example is the U.S. Census Bureau Population Clock: as of September 30, 2026, it showed 342,775,604 U.S. residents, with one birth every 8 seconds, one death every 11 seconds, and a net gain of one person every 26 seconds, according to the U.S. Census Bureau.

The Six Parts Every Number Counter Shares

Every number counter, whether a browser click tool or a web animation, is configured by the same six attributes:

Start value — where the count begins (usually 0)
Target value — the final figure
Step — how much each increment adds (usually 1, but character counters track every keystroke)
Duration — how long the climb takes
Easing — how the speed accelerates or decelerates
Trigger — what starts the count (a click, a viewport entry, a slide build, or a system clock)

For a tally counter, the step is 1 and the trigger is a manual click. For an animated web statistic, the step is a computed increment and the trigger is a viewport intersection. The six parts stay fixed; only their settings change.

Which Number Counter Do You Need? A Five-Type Decision Table

Existing results are siloed by platform—a dictionary entry, a Divi 5 module page, a tally tool, a paid snippet, a PowerPoint tutorial—so no single page helps you choose a type. The decision table below does that.

Use case	Counter type	Where it runs	Trigger	What it must persist
Counting reps, attendance, inventory, outreach	Tally / click counter	Browser tool	Manual click	Local (browser) persistence
Proving a statistic on a landing page or dashboard	Animated web stat counter	JavaScript or CMS module	Viewport entry	Nothing persisted
Fitting copy into a limit	Character counter	Browser tool	Keystroke	Live character, word and space totals
Revealing figures in a deck or video	Slide / video counter	PowerPoint/WPS, After Effects	Slide build or keyframe	Fixed target
Continuously changing public data	Live data clock	Server-rendered or scripted	Wall clock	External data source

Rows 1 and 3 continue in the use-case section below. Rows 2 and 4 continue in the build and platform sections.

How Do You Build an Animated Number Counter in Vanilla JavaScript?

The full working code is right here, inline. No €9.90/month paywall, no page-builder lock-in, no After Effects dependency. You need three pieces: an HTML block of stat cards, a CSS rule for tabular-nums, and a script tag.

Each stat card carries data-target and optional data-suffix or data-prefix attributes, so the same script drives every figure. According to Linkora-social issue #191 (opened September 21, 2026), the required behavior for creator dashboard stat cards is a 0-to-final climb over 1.2 seconds using requestAnimationFrame—no library dependency, ease-out, and respecting prefers-reduced-motion.

Step 1: Mark Up the Target, Suffix and Step Size

Start with the HTML. Each stat card holds a value element with its target:

<div class="stat-card">
  <div class="stat-value" data-target="2847" data-suffix="">0</div>
  <div class="stat-label">Users</div>
</div>

Add font-variant-numeric: tabular-nums to the value element. That keeps digit widths from jittering and stops the surrounding layout from shifting while the number climbs. If a card needs a unit, either put it in data-suffix or write it in a sibling <small> element. Step size stays at 1 for whole-number statistics, unless you’re counting batches by hand.

Step 2: Write the requestAnimationFrame Loop with Ease-Out

Set the duration in milliseconds — 1200 ms is the baseline from the Linkora-social requirement. Derive progress from elapsed time, not from frames completed:

function animateCounter(el) {
  const target = parseInt(el.getAttribute('data-target'), 10);
  const suffix = el.getAttribute('data-suffix') || '';
  const duration = 1200;
  const start = performance.now();

  function update(now) {
    const progress = Math.min((now - start) / duration, 1);
    const eased = 1 - Math.pow(1 - progress, 3); // cubic ease-out
    const current = Math.floor(eased * target);
    el.textContent = current + suffix;
    if (progress < 1) requestAnimationFrame(update);
    else el.textContent = target + suffix;
  }
  requestAnimationFrame(update);
}

Don’t count frames. Compute progress from elapsed time so a 121 fps display and a 60 Hz display finish together.

Step 3: Fire the Count Once with IntersectionObserver

Trigger once when the element enters the viewport, then stop observing so the count never replays when you scroll back. The Effect.Labs CSR report example shows this pattern exactly: six figures in a three-column grid, a counter climbing 0 → 918, fired once by an IntersectionObserver with threshold 0.3.

const observer = new IntersectionObserver((entries) => {
  entries.forEach(entry => {
    if (entry.isIntersecting) {
      animateCounter(entry.target);
      observer.unobserve(entry.target);
    }
  });
}, { threshold: 0.3 });

document.querySelectorAll('.stat-value').forEach(el => observer.observe(el));

If the grid is above the fold, it fires on load with no interaction. If it’s below, it waits for the user to scroll into the threshold.

Step 4: Add the prefers-reduced-motion Short-Circuit

Write the final value directly on load — no animation, no intermediate frames:

const reduce = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
if (reduce) {
  document.querySelectorAll('.stat-value').forEach(el => {
    el.textContent = el.getAttribute('data-target') + (el.getAttribute('data-suffix') || '');
  });
} else {
  // set up observer as above
}

This is not a shortened animation. It’s a bypass—the number is simply there.

Count-Up Animation Duration and Easing: Frames vs Milliseconds

Here’s a pitfall no competitor explains: when duration is expressed as a frame count, the same counter runs at different real speeds on different displays. Effect.Labs measured this (updated September 30, 2026): a 125-step climb took 2.08 seconds on a 60 Hz screen but 1.04 seconds at 121 fps, using a step of 22.78 per frame for a target of 2,847.

The rule: calculate progress as elapsed time divided by duration, never as frames completed. That one change makes the counter finish at the same real-world speed on a 30 Hz laptop in power-saving mode and a 121 fps Chromium.

Easing guidance by content type: use ease-out for a single hero number so it decelerates into the final value. Use a near-linear climb for equal-weight statistics that should feel simultaneous. Duration guidance by content type: about 1.2 seconds for dashboard stat cards, shorter for rows of four or more figures revealed together. Frame-count animation is still fine for fixed-frame video and slide output, where the author controls the frame rate.

Animated Number Counter Accessibility and Performance Checks

Only one source on the SERP touches these trade-offs, and it hides them inside a paid product page. The checks below are the ones that matter most.

Screen readers: A screen reader that lands mid-climb reads an intermediate value. Hide the climbing digits with aria-hidden="true" and put the final value in an aria-label on the card. According to the Effect.Labs municipal election example, four equal-weight figures (registered voters, votes cast, spoilt ballots, turnout) were animated together in a four-card row with threshold: 0.5, each card carrying an aria-label with the final value and the animated digits hidden from assistive technology.

Do not use aria-live: Wrapping a climbing number in an aria-live region announces every intermediate value and stutters. Keep the live region off the climbing element.

Reduced motion: prefers-reduced-motion must write the final value immediately rather than shortening the animation. A shortened animation still triggers motion sensitivity; a direct write does not.

tabular-nums: font-variant-numeric: tabular-nums stops digit widths from jittering and the surrounding layout from shifting. Without it, every frame reflows the card.

Contrast: Gradient-filled digits at body-text sizes measured as low as 4.4:1 in the Effect.Labs example. Keep the counter text at or above the 4.5:1 threshold for body text.

Performance: Use one observer for a whole grid, unobserve after firing, and update via textContent rather than innerHTML to avoid re-parsing the DOM on every frame.

Number Counters Without Code: Tally Tools, PowerPoint, After Effects and Divi 5

A free online number counter doesn’t require an account—click to add or subtract, set a custom step size, use keyboard shortcuts, and the count stores locally in your browser. The privacy trade-off is clear: browser-local counting leaves nothing on a server, but clearing your browser data clears the count.

PowerPoint and WPS Presentation apply the Dynamic Number effect to a text box or table cell, controlled by the slide’s animation timeline. After Effects uses the Numbers preset with Slider Control, where a slider keyframe range supplies the start and end values and the results can be rendered to MP4. Divi 5 provides number, circle, and countdown counter modules, configured through a visual panel instead of a script.

Version anchoring keeps instructions correct. IntersectionObserver has shipped since Chrome 51, Firefox 55, and Safari 12.1; the background-clip: text shorthand used for gradient digits works in Chrome and Edge 120+, Firefox 49+, and Safari 14+, per Effect.Labs compatibility notes. Skip the code path when slides and video handle one-off storytelling, or when a non-developer owns the site and a page-builder module is the safer maintenance choice.

Browser Tools: Tally, Click and Character Counters

A free online tally counter like tallycount.online runs without an account. You can create multiple counters, organize them into categories, set custom step sizes (2s, 5s, 10s, or any value), enable negative counting, and rely on automatic browser saving. This is the right row in the decision table when privacy beats persistence—nothing is stored server-side, but clearing browser data wipes the count. For counting that also needs a target goal with visual progress tracking, a dedicated online number counter adds named counters, quick presets, CSV export, and 30-day totals on top of the same no-account, browser-local setup.

Slides and Video: PowerPoint, WPS and After Effects

According to the WPS Office Academy (September 14, 2026), you can apply the Dynamic Number effect to a text box or table cell, control it from the slide timeline, and hold Ctrl to select multiple number boxes and add the effect once. In After Effects, the Numbers preset paired with Slider Control uses keyframe values for start and end, and the composition can be rendered to MP4 for fixed-frame output.

What Is a Number Counter Used For? Six Real-World Workflows

Each audience below needs a specific counter type and a specific increment behavior—not a generic one-line link.

Cold callers and outreach teams use a click counter with a step of 1 and a daily reset. Counting in-browser keeps prospect details off paper.

Gym-goers and coaches need rep counting with a step of 1 and a decrement button for miscounts.

Teachers and event staff count attendance and guests, where a negative step corrects over-counts without resetting the total.

Warehouse and inventory teams run cycle counting on a clicker, where the final total must reconcile against the system figure.

Devotional counting (Tasbih/Zikar) and habit tracking rely on persistent local counts that survive a page refresh.

Character and number counting is its own category. According to easycalculator.org (updated September 20, 2026), a standard SMS is limited to 160 characters, Google search titles cut off after around 60 characters, and Twitter/X posts are capped at 280. Reading time averages 200 words per minute and speaking time 130.

A counter can also act as a data-integrity check instead of a display. According to HPC-SimTools/IPS-framework issue #258 (opened September 25, 2026), a sequence number counter on the Portal Bridge must increment by exactly 1 per event, because a missing number in the sequence implies a missing event.

Live data clocks close the list. The U.S. Census Bureau ranked the most populous countries as of July 1, 2026: India at 1,429,700,205; China at 1,405,918,803; and the United States at 342,620,143.

Conclusion

A number counter is one idea—increment a value—wearing five different costumes. So the real decision is picking the type, not the platform. Pick your row in the decision table, then copy the vanilla JavaScript counter from Steps 1–4 if you’re building for the web. Or jump to the no-code section if a page builder, deck, or video tool already owns the output. Either way, set the duration in milliseconds and ship the reduced-motion fallback before you publish.

FAQ

What is the difference between a number counter, a tally counter, and a character counter?

All three increment a value; the difference is what gets counted. A tally counter adds whole events on a click. A character counter measures the length of text as you type. A number counter is the umbrella term covering both, plus animated web counters. Choose by unit: events, characters, or a statistic you want to reveal.

How long should an animated number counter take to finish?

About 1.2 seconds with an ease-out curve is a reliable default for a single hero or stat-card figure. Rows of four or more equal-weight figures should run shorter so they finish together. Measure duration in milliseconds, not frames—a frame-based climb runs at different speeds on 60 Hz and high-refresh displays.

Do animated number counters hurt accessibility or SEO?

Not if the final value is in the HTML and the climbing digits are hidden from assistive technology with aria-hidden plus an aria-label. Avoid aria-live on a climbing number, which announces every intermediate value. Crawlers read the static final value, so the animation itself has no SEO cost—only the missing static text would.

Can you build a number counter without JavaScript?

For tally counting, yes—a free online click counter or a physical clicker needs no code. For a one-time count-up on a page, CSS-only tricks exist but cannot read a target value or respect reduced-motion cleanly. For slide and video output, the Dynamic Number effect in PowerPoint/WPS or the After Effects Numbers preset replaces code entirely.

What is a number counter used for in real life?

Attendance, reps, inventory audits, guest counting, and outreach logging. Proving statistics in CSR reports, dashboards, and election results. Fitting copy to limits—SMS at 160 characters, X posts at 280—and verifying data integrity when a sequence must advance by 1.

2026年10月16日

URL Formatter: Decode, Parse & Re-Encode Any URL

A URL formatter takes a messy or percent-encoded web address and makes it readable. It splits the URL into scheme, host, port, path, query, and fragment, decodes values like %20 back into plain text, and re-encodes unsafe characters according to RFC 3986 and the current WHATWG URL Standard (last updated September 2026).

“URL Formatter” Means Three Different Jobs — Which One Do You Need?

The term “URL formatter” is used loosely, and most tool pages never define it. In practice, it covers three different jobs: decoding percent-encoding back into readable text, parsing a link into its named components, and normalizing a URL so that parsing and re-serializing it produces a stable result. The current WHATWG URL Standard is a Living Standard last updated 10 September 2026, and it defines the parse-and-serialize behavior that browsers actually implement. That is why a formatter can be both a readability tool and a consistency tool.

You can pick the right job from the shape of your input:

A link full of %20, %26 or %E0%A4 runs → you need decode.
A long link you want to see inside (UTM tags, API parameters, redirect targets) → you need parse.
A URL containing spaces, &, non-ASCII characters, or a whole URL nested inside a parameter → you need encode.

One clarification saves time: a URL formatter is not an HTML formatter or beautifier. An HTML formatter such as Static.app’s HTML formatter adds indentation and line breaks to markup and does nothing to encoding. The HTML testing tools that rank for similar queries operate on page markup rather than link syntax. If your input is a link, you want a URL tool; if your input is a page of tags, you want an HTML tool.

Most online URL formatter tools do all three jobs in one page, client-side, with no signup — which means you can decode, parse and re-encode without installing anything.

Decode: turn %20 and %C3%A9 back into readable text

Decoding reverses percent-encoding: each %XX sequence is converted back into the byte it represents, and multi-byte sequences are reassembled into a single character. This is the step that turns ?q=running%20shoes into ?q=running shoes, and it is the step most often needed when reading server logs, API responses or tracking links.

Parse: split a long link into scheme, host, path, query, fragment

Parsing separates a URL into named components so you can read one part in isolation instead of scanning the whole string. The MDN URL API documentation exposes exactly these pieces as properties — protocol, host, port, pathname, search, hash — and notes that the URL constructor “can be used to normalize and encode a URL directly.”

Normalize: make the same URL format identically every time

Normalization is the property that parsing and re-serializing the same input keeps producing the same output. The WHATWG URL Standard states as an explicit goal that the parser, serializer and API combination “guarantee idempotence” — a non-failure result of a parse-then-serialize operation should not change with further parse-then-serialize operations applied to it. That is what makes two URLs comparable.

How to Format a URL in 4 Steps (Decode, Parse, Verify)

This is a repeatable order of operations, and the standard you check the result against matters as much as the steps.

Step 1 — Identify the task before touching the string. Decoding an entire URL, decoding a single parameter value, and encoding one value produce three different outputs. Picking the wrong one is the most common cause of broken links, because the structural characters that hold the URL together get treated as data.

Step 2 — Parse first, never string-replace. Paste the URL into an online URL formatter or pass it to a URL object so the components separate correctly. The query is everything between ? and #; the fragment is everything after #. Once you have that split, you know precisely which substring is data and which is structure, and you can stop guessing with find-and-replace.

Step 3 — Encode or decode only the query values. Never encode the structural characters :, / or ?. The correct treatment is per-value, encodeURIComponent-style, rather than treating the whole URL as a single string. The WHATWG URL Standard defines distinct percent-encode sets for fragments, queries, paths and userinfo, which is the formal reason a single one-shot replacement cannot be correct for every position in a URL.

Step 4 — Verify by re-parsing the output and counting key=value pairs. A URL that round-trips back to the same number of parameters, with the same decoded values, is correct. If your input had three parameters and the output parses as four, an unencoded separator leaked into the data.

The two things that make this a how-to rather than a definition are the fixed execution order above and a standard to check against: RFC 3986 for percent-encoding rules, and the WHATWG URL Standard for parsing and serialization. According to MDN’s URL API page, the URL interface’s job is to “parse, construct, normalize, and encode URLs,” which is precisely the three-part job a good formatter exposes.

Before and after: one messy URL, fully formatted

Take a URL copied from a chat message: https://docs.foobar.com:8000/knowledge/area/?name=article&topic=seo#top — this is the component example published in Unicode UTS #58. A formatter splits it into scheme (https://), host (docs.foobar.com), port (:8000), path (/knowledge/area/), query (?name=article&topic=seo) and fragment (#top).

Now take a messier real-world variant: the query arrives as ?q=New%20York%20%26%20Los%20Angeles&utm_source=newsletter. Parsing plus decoding yields two readable pairs — q = New York & Los Angeles and utm_source = newsletter — and the %26 stays inside the value instead of splitting it into two parameters. Re-encoding the same URL produces output identical to the input, which is the round-trip check from Step 4.

The 6 URL Components Every Formatter Splits Out

Scheme, host, port, path, query and fragment form the skeleton used by every parser, by the MDN URL API, by the WHATWG URL Standard and by UTS #58. Mapping your own URL onto these six slots is the fastest way to understand what a formatter is showing you.

Component	Example (from UTS #58)	Sent to the server?
Scheme	`https://`	Yes (defines the request type)
Host (incl. domain)	`docs.foobar.com`	Yes
Port	`:8000`	Yes
Path	`/knowledge/area/`	Yes
Query	`?name=article&topic=seo`	Yes
Fragment	`#top`	No — browser-side only

Two components cause most confusion. The query starts at ? and is transmitted to the server; the fragment starts at # and is kept in the browser. Static.app’s URL parser page makes the same distinction in its output, splitting a pasted URL into “host, full URL, path, query string, and hash” with a decoded parameter table.

Scheme, host and port: the origin

The scheme, host and port together identify the resource’s origin. In the MDN URL API, origin is a read-only property returning exactly those three pieces, while host combines the hostname and the port when a port was specified. Non-ASCII hostnames take a separate path through IDNA processing rather than percent-encoding, which is why a domain like bücher.de is handled differently from an accented character inside a path.

Path and query: what the server sees

Path and query are the components you can safely edit without changing which server answers. The path is a list of segments separated by /, which is also why an encoded %2F inside a value is treated as data while a literal / creates a new segment. The query is typically a list of key-value pairs separated by &, with each key separated from its value by =, as UTS #58 describes.

Fragment and text directives (:#:~:text=)

The fragment has structures defined by web applications rather than by the URL syntax itself, and it can end with one or more fragment directives that begin with the separator :~:. UTS #58 gives the example https://example.com#:~:text=foo&text=bar, and notes that inside a fragment directive the comma and ampersand act as separators that clear the open-bracket stack — a detail most formatters simply ignore because the fragment never reaches the server.

Percent-Encoding Explained: Why %20, %26 and %C3%A9 Exist

Percent-encoding follows one deterministic rule: take the character’s byte value, express it in hexadecimal, and prefix it with %. AuraxTools’ URL encoder reference lists the mappings that cover almost every real-world case.

Character	Encoded	Why it must be encoded
Space	`%20`	Illegal in URLs; breaks parsing at every layer
`&`	`%26`	Query parameter separator — splits data accidentally
`=`	`%3D`	Key-value separator — corrupts parameter structure
`+`	`%2B`	Read as a space in form-encoded data
`#`	`%23`	Fragment identifier — truncates everything after it
`?`	`%3F`	Query start marker — confuses the parser mid-value
`/`	`%2F`	Path separator — becomes a directory delimiter
`:`	`%3A`	Protocol-host separator — must be encoded inside values
`@`	`%40`	Separates credentials from host
`%`	`%25`	The encoding prefix itself
`é`, `ü`, `ñ`	`%C3%A9`…	Non-ASCII characters encode as multi-byte UTF-8

The underlying reason is transport: as AuraxTools puts it, HTTP only understands the ASCII set, so spaces, ampersands, accented letters and emoji either carry special meaning or cannot travel safely. The standard governing the substitution is RFC 3986, and the same hex-substitution logic appears across languages — encodeURIComponent() in JavaScript, urllib.parse.quote() in Python, urlencode() in PHP.

Reserved vs unreserved characters

RFC 3986 divides characters into those that change the URL’s meaning if left literal (reserved, such as &, =, ?, #) and those that carry no reserved purpose (unreserved marks such as -, ., !, ~, *, ', (, )). MDN’s encodeURI() reference documents that both encodeURI() and encodeURIComponent() leave the unreserved marks untouched, because they are allowed in a URI as-is. Reserved characters inside a data value are a different matter: they must be encoded or they will be read as structure.

One byte or several? Why é = %C3%A9

é is not one byte. It is a two-byte UTF-8 sequence, and each byte is escaped separately, producing %C3%A9. MDN’s encodeURI() documentation explains the general mechanism: characters are replaced by one, two, three or four escape sequences representing the UTF-8 encoding of the character. That is why a single accented letter can consume six characters in the encoded form, and why an entire non-Latin sentence expands into a long %XX run.

Space: %20 or +?

%20 is the correct encoding for a space in a URL path and in modern query encoding. The + character means space only in application/x-www-form-urlencoded data — the format HTML forms submit — and in query strings parsed under that convention. The WHATWG URL Standard makes the distinction explicit by defining the application/x-www-form-urlencoded percent-encode set, which is the only set that maps space to +. Outside form-encoded bodies, a + in a value is a literal plus sign.

Query Strings: Decoding key=value Parameters with URLSearchParams

Query parameters are the part users need decoded most often — UTM tags, API parameters, search terms — and the part most often decoded incorrectly. The official read/write API for query strings is URLSearchParams, exposed by the URL API’s searchParams property; per MDN’s URL API page (last modified 28 September 2026), the interface has been Baseline widely available across browsers since July 2015. It handles encoding, duplicate keys and ordering without regular expressions.

The rule that prevents damage: never decode the entire URL string at once. If you do, the ?, & and = characters get converted into data along with everything else, and the parameter list collapses into one meaningless value. Decode per value, or let URLSearchParams return already-decoded pairs.

Reading parameters without regex (URLSearchParams)

Iterating url.searchParams yields [key, value] pairs with percent-encoding already resolved, which is what the encoded-parameter table in a formatter is showing you. Duplicate keys and array-style parameters should be displayed as a list of pairs rather than last-value-wins, because ?tag=a&tag=b legitimately carries two values and collapsing it silently loses data.

Decoding UTM and ad-tracking links

Marketers receive tracking links from email platforms and ad networks in percent-encoded form, where campaign names appear as Summer%20Sale or Q3%20Email%20%26%20Social. Decoding them reveals the real campaign name and the real destination. The reverse matters just as much before launch: encoding UTM values prevents a space or ampersand from splitting one tracking parameter into two, which corrupts attribution silently — the link still loads, but the campaign data no longer matches. AuraxTools documents the same failure mode in its URL-encoding reference and warns that its tool flags strings that appear already encoded, which guards against the double-encoding mistake covered next.

encodeURI() vs encodeURIComponent(): The Bug That Duplicates Your Parameters

The rule fits in one line: encodeURI() is for a complete URL you are not editing; encodeURIComponent() is for a single value you are inserting into a URL.

The difference is the character set each one escapes. Per MDN’s encodeURI() documentation (page last modified 2 September 2026), encodeURI() leaves the reserved set ; / ? : @ & = + $ , # untouched, because those characters may be part of URI syntax. encodeURIComponent() encodes that identical set to %3B%2C%2F%3F%3A%40%26%3D%2B%24%23. Both leave the unreserved marks -._!~*'() alone, and both always encode a space as %20.

How the “Ben & Jerry’s” bug happens

MDN reproduces the failure directly. With name = "Ben & Jerry's", building a link as encodeURI(\https://example.com/?choice=${name}`)produceshttps://example.com/?choice=Ben%20&%20Jerry’s. Parsing that string back yields two parameters —[[‘choice’, ‘Ben ‘], [” Jerry’s”, ”]]— because the ampersand survived as a separator. UsingencodeURIComponent(name)produces?choice=Ben%20%26%20Jerry’s, which parses back to a single correct pair:[[‘choice’, “Ben & Jerry’s”]]`. One parameter became two because the wrong function was used on a value.

The double-encoding trap: %20 vs %2520

Encoding an already-encoded value turns %20 into %2520, because the percent sign itself gets escaped to %25. The server then reads the literal text %20 instead of a space, and the parameter matches nothing. The detection method is simple: look for %25 in the output of an encode operation. If it appears where your input had no literal percent sign, you encoded something that was already encoded.

MDN’s own example of correct whole-URL encoding is encodeURI("https://mozilla.org/?x=шеллы"), which returns "https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B" and is reversible with decodeURI(). That worked because the Cyrillic text sat inside a value that needed encoding, while the URL’s own structure was left intact.

Which URL Standard Applies? RFC 3986 vs WHATWG vs UTS #46/#58

Four documents are relevant to a URL formatter, and they operate at different layers. Knowing which one your tool is following tells you what its output means.

Standard	Scope	Status / anchor date
RFC 3986	URI syntax and percent-encoding rules	The encoding rules MDN’s URL API cites; language encoders follow it
WHATWG URL Standard	How browsers parse and serialize URLs	Living Standard, last updated 10 September 2026
UTS #46	IDNA / Punycode processing for domain names	Referenced by the WHATWG URL Standard for IDNA compatibility processing
UTS #58	Link detection and minimal escaping in plain text	Version 18.0, 14 September 2026, Revision 3

The WHATWG URL Standard is explicit about its relationship to the RFCs: one of its stated goals is to “align RFC 3986 and RFC 3987 with contemporary implementations and obsolete the RFCs in the process,” on the grounds that concepts like spaces, other illegal code points, query encoding, equality and canonicalization were not fully shared or defined between them. It also states the intent to unify the terminology — “URI and IRI are just confusing” — and to standardize on the term URL.

The practical consequence is straightforward: when an RFC-derived encoder and a browser disagree about how a URL parses, the browser follows WHATWG. The standard worth checking your output against is the one matching the runtime you ship to.

Where RFC 3986 and the browser disagree

The clearest disagreements are in host handling. The WHATWG standard enumerates validation errors and failures that RFC-derived parsers do not treat the same way: forbidden host code points, IPv4 addresses with too few or too many parts (https://1.2.3/, https://1.2.3.4.5/), IPv4 parts exceeding 255, IPv6 addresses with too many pieces or multiple compressions, and ports above the valid range. It also documents that hosts are percent-decoded before processing when a URL is special, so https://exa%23mple.org becomes exa#mple.org and triggers an IDNA error. A formatter that follows WHATWG will flag these; a string-level encoder will not.

Why Do Non-English URLs Explode into %E0%A4… Strings?

Browsers, copied links and clipboard text frequently over-escape. Characters that are perfectly valid in a URL get converted into multi-byte UTF-8 %XX runs even when escaping is not required, and the result is technically functional but effectively unreadable.

UTS #58 documents real examples. A YouTube handle shown as www.youtube.com/@핑크퐁 is copied in many browsers as https://www.youtube.com/@%ED%95%91%ED%81%AC%ED%90%81. A Wikipedia article at https://en.wikipedia.org/wiki/Antonín_Dvořák is copied as https://en.wikipedia.org/wiki/Anton%C3%ADn_Dvo%C5%99%C3%A1k. Hindi text expands even further: https://hi.wikipedia.org/wiki/महात्मा_गांधी becomes a %E0%A4%AE%E0%A4%B9%E0%A4%BE%E0%A4%A4%E0%A5%8D%E0%A4%AE%E0%A4%BE… string.

The report’s assessment is blunt: while many people cannot read महात्मा_गांधी, nobody can read the escaped version. The cost is practical — over-escaped links are unreadable in chat, email and print, they add length where length may be limited, and the unescaped forms work fine as plain text and display properly in the address bar when pasted back.

IDNA and Punycode hostnames

Domain names take a different path from paths and queries. Non-ASCII hosts go through IDNA processing and appear in Punycode form, which is why UTS #58 says bücher.de/bücher should be displayed — not xn--bcher-kva.de/b%C3%BCcher. The WHATWG URL Standard applies the same principle in its host parsing examples, where faß.example serializes as xn--fa-hia.example in domain form. A formatter with an IDNA-aware display can show the readable host while the underlying transmission form stays ASCII.

Minimal escaping: when one character is enough

UTS #58 defines a minimal escaping rule for the path, query and fragment: a character is percent-escaped only if it would otherwise terminate link detection, if it is an unmatched closing bracket, or if it is one of the part’s own separators. The demonstration case is https://ja.wikipedia.org/wiki/アルベルト%29アインシュタイン, where exactly one character needs escaping — the unmatched %29 parenthesis — while the Japanese text stays readable.

The payoff is that a minimally escaped URL inside flowing text is still detected as one complete link, and it still works when pasted into a major browser’s address bar. A formatter that applies minimal escaping produces output that looks like the URL people typed, not a wall of hex.

Copy-Paste Code: JavaScript, Python, PHP and curl

No tool page or specification page in this space provides runnable cross-language snippets, so here are four short blocks with the round-trip check built in. All four follow the same RFC 3986 percent-encoding logic described in AuraxTools’ reference.

JavaScript and Node.js

const u = new URL("https://example.com/search?q=New%20York%20%26%20LA#top");
console.log(u.hostname);          // example.com
console.log(u.pathname);          // /search
console.log(u.hash);              // #top
console.log([...u.searchParams]); // [['q', 'New York & LA']]

// Building a value correctly:
const name = "Ben & Jerry's";
const good = `https://example.com/?choice=${encodeURIComponent(name)}`;
console.log([...new URL(good).searchParams]); // [['choice', "Ben & Jerry's"]]

The mistake that double-encodes here is calling encodeURIComponent() on a value you already decoded and re-encoded, or wrapping a whole URL in encodeURIComponent(), which turns https:// into https%3A%2F%2F.

Python 3

from urllib.parse import urlparse, parse_qs, quote, quote_plus, urlencode

u = urlparse("https://example.com/search?q=a%20b%26c#top")
print(u.scheme, u.netloc, u.path, u.fragment)  # https example.com /search top
print(parse_qs(u.query))                       # {'q': ['a b&c']}

print(quote("a b&c"))       # a%20b%26c
print(quote_plus("a b&c"))  # a+b%26c
print(urlencode({"q": "a b&c"}))  # q=a+b%26c

urlparse() splits the components, parse_qs() decodes the values, and the quote() versus quote_plus() split mirrors the %20 versus + distinction: use quote() for path-style output, quote_plus() or urlencode() when the receiving side expects form-encoded data. The double-encoding trap is passing an already-encoded query string into urlencode() again.

PHP and the command line

$u = parse_url("https://example.com/search?q=a%20b%26c#top");
parse_str($u['query'], $params);
print_r($params);                    // ['q' => 'a b&c']
echo rawurlencode("a b&c");          // a%20b%26c
echo urlencode("a b&c");             // a+b%26c

parse_url() splits the URL, parse_str() decodes the query, and rawurlencode() versus urlencode() separates the same two space conventions: rawurlencode() maps space to %20, urlencode() maps it to +.

On the command line, let curl do the escaping rather than writing %20 by hand:

curl --get --data-urlencode 'q=a b&c' https://example.com/search

The --data-urlencode flag encodes the value before it is placed in the query string, which is the same per-value treatment as encodeURIComponent(). Writing the URL out yourself with a raw & inside a value is what splits one parameter into two.

How to Pick a Safe, Client-Side URL Formatter Tool

A formatter is a viewer, not a validator. The WHATWG URL Standard is direct on this point in its security considerations: when a URL passes from party A to B, “B should never trust A, as at some point URLs from A can come from untrusted sources.” A tool that decodes a URL for inspection tells you nothing about whether that URL is safe, and it must not be used as a security check.

Comparison tables on tool sites — including Static.app’s own table against FreeFormatter, Browserling and CyberChef — are vendor self-assessments. Useful, but not neutral. A neutral evaluation rests on observable behavior instead.

One timeliness caveat matters when reading tool marketing: as of 3 October 2026, the tool pages referenced here — Static.app’s URL parser, AuraxTools’ URL encoder, and FreeDailyPro’s URL encoder — did not display a last-updated date. Capability claims on undated pages should be checked against current browser behavior rather than assumed current.

Six checkboxes before you paste a production URL

Client-side processing. The tool parses in JavaScript using the URL API and URLSearchParams rather than posting your URL to a server. Static.app and AuraxTools both claim all processing happens in the browser; AuraxTools states “0 bytes” sent to any server.
A decoded parameter table. The output should list each query key with its decoded value, not a single decoded blob.
Multi-byte UTF-8 support. Feed it %C3%A9 and confirm it returns é, not two mojibake characters.
A double-encoding warning. Good tools flag input that already looks encoded. AuraxTools explicitly says it detects and warns when a string appears already encoded.
IPv6 and IDNA host handling. Test [::1] and a Punycode or non-ASCII host to see whether the parser treats the host as a host or as a path fragment.
Original and encoded side by side. Without both columns you cannot verify the round trip from Step 4 of the how-to.

Treat “data never leaves your browser” and “no signup” as vendor claims until you confirm them. The confirmation method is simple: open developer tools, watch the network tab while you paste a test URL, or disable connectivity and retry. If the tool still works offline, the processing is local.

For Marketers: Decode UTM Links, Then Re-Encode Before Launch

The non-developer workflow is short. Paste a received campaign link into a formatter to read three things: the real destination page, the real campaign name hiding behind %20 and %26, and any nested redirect URL that has itself been encoded as a parameter value. Redirect-based tracking, as AuraxTools describes it, works by embedding the destination URL inside the redirect URL’s query string, which means the destination’s own :, / and ? arrive fully encoded.

Before publishing, check that campaign names containing spaces or ampersands are encoded. This is the “Ben & Jerry’s” failure from MDN translated into marketing terms: an unencoded ampersand turns one parameter into two, and attribution breaks without producing any visible error. AuraxTools’ guidance on UTM parameters makes the same point — a campaign name like Summer Sale 2025 or Q3 Email & Social left unencoded “will silently corrupt your campaign’s query string,” while encoding the value before it is appended costs seconds.

Nested URLs need the per-value rule again: encode the entire destination URL as one value when it is inserted into a redirect= or url= parameter, exactly as encodeURIComponent() does.

The one-line warning that ties this section together: decoding is for reading, not for re-publishing. Decode to inspect, then re-encode the value before it goes back into a live link.

Conclusion

A URL formatter isn’t one tool but three jobs — decode percent-encoding, parse a link into its six components, and normalize it so parse-then-serialize is stable — and the encoding rules come from RFC 3986 while the parsing behavior you actually ship against comes from the current WHATWG URL Standard, last updated 10 September 2026.

Paste your URL into a client-side URL formatter first to see the decoded parameter pairs, then fix the problem at its source: use encodeURIComponent(), Python’s quote(), PHP’s rawurlencode(), or curl --data-urlencode on each individual value — never on the whole URL — and re-parse the output to confirm the parameter count and values are unchanged.

FAQ

Is a URL formatter the same thing as a URL encoder/decoder?

It overlaps but is broader. Encoding and decoding are two of its three jobs. A formatter also parses a URL into scheme, host, port, path, query and fragment, and can normalize the result so repeated parsing produces the same output. A pure encoder only converts characters to %XX form and back, with no component breakdown and no structural view of the link.

Why does my URL contain %20, %26 or %C3%A9 — and is it broken?

It is not broken. Percent-encoding replaces characters that would otherwise change the URL’s meaning: %20 is a space, %26 is a literal &, and %25 is a literal percent sign. %C3%A9 is a two-byte UTF-8 sequence representing é, because non-ASCII characters always occupy multiple %XX bytes. It only becomes a problem when a value was encoded twice, producing %2520.

Can I format or decode a URL without sending it to a server?

Yes. Browser-based tools can do the entire job in JavaScript using the URL API and URLSearchParams, both of which are Baseline widely available since July 2015 according to MDN. You can verify the claim yourself: open developer tools and watch the network tab, disconnect from the network and retry, or paste a test URL and confirm the result still appears offline.

What is the difference between encodeURI() and encodeURIComponent()?

encodeURI() encodes a complete URL and leaves ; / ? : @ & = + $ , # intact so the structure survives. encodeURIComponent() encodes a single value and escapes that same set to %3B%2C%2F%3F%3A%40%26%3D%2B%24%23. Use encodeURI() for whole URLs you are not editing, and encodeURIComponent() for any value you are inserting into one.

Why does copying a link with non-English characters give me a long %E0%A4… string?

Browsers and clipboard handlers often over-escape readable characters into multi-byte UTF-8 sequences. UTS #58 (Version 18.0, 14 September 2026) shows real examples from YouTube and Wikipedia, and its minimal-escaping rule implies far fewer characters need encoding than most tools produce — in one documented case, only a single unmatched %29 required escaping. The link still works; it is simply harder to read and share.

Is a “URL formatter” the same as an HTML formatter?

No. An HTML formatter indents and beautifies markup and does nothing to encoding. The two get matched by the same search query, which is why results often look unrelated to what you need. If your input is a link, you want a URL formatter; if your input is a page of tags, you want an HTML formatter.

2026年10月16日

Seconds to Minutes: Exact Formula, Table & Calculator

To convert seconds to minutes, divide the number of seconds by 60. For example, 450 ÷ 60 = 7.5 minutes, or 7 minutes 30 seconds. The factor is exact: the SI system defines one minute as exactly 60 seconds, so there is no rounding or approximation.

How Do You Convert Seconds to Minutes? The ÷60 Formula

The seconds to minutes conversion comes down to one operation: minutes = seconds ÷ 60. It is the same as multiplying the seconds by 1/60. Everything else on this page — the table, the calculator, the spreadsheet formula — is just another way to express that one division.

This conversion is unusual because there is no uncertainty. According to the BIPM SI Brochure, one minute is exactly 60 seconds, with no uncertainty attached to the factor. There is nothing to round, no precision setting to choose, and no version of the answer that changes when a source updates or a page refreshes. A search for “seconds to minutes” returns the same exact number today as it will in any future year.

The input unit is defined just as tightly. The second is the SI base unit of time, defined as the duration of 9,192,631,770 periods of the caesium-133 transition — a standard unchanged since 1967. Because both units are fixed by definition, the ÷60 relationship is one of the few everyday conversions where the input is exactly as precise as the output.

Put the inverse beside the rule, and any answer becomes easy to check: minutes × 60 = seconds. If 450 ÷ 60 = 7.5, then 7.5 × 60 must return 450. If it does not, the arithmetic slipped somewhere.

The one decision the formula does not make for you is the output format. There are two valid ways to express the same result — decimal minutes (7.5 min) and minutes and seconds (7 min 30 s) — and they are separated in the next section because mixing them is the most common error in this conversion.

This basic operation is common enough that the scale is worth noting: the wikiHow conversion guide reviewed by Grace Imson, MA, a math teacher with over 40 years of experience, has been viewed 426,399 times. That gives a light sense of how routine this calculation is.

The formula in one line

Minutes = Seconds ÷ 60. The reverse is Seconds = Minutes × 60. Applied to 450 seconds: 450 ÷ 60 = 7.5. Applied back: 7.5 × 60 = 450.

Worked example: 450 seconds in minutes

Start with the division: 450 ÷ 60 = 7.5 minutes in decimal form. To express the same value as minutes and seconds, take the whole part as 7 minutes and convert the fractional 0.5 back by multiplying: 0.5 × 60 = 30 seconds. The result is 450 seconds = 7.5 minutes = 7 minutes 30 seconds. Verify by reversing: (7 × 60) + 30 = 450. Brighterly’s conversion guide uses this same 450-second example as its headline worked case.

Seconds to Minutes Conversion Table (Landmark Values)

These are the values readers look up most often. Every row is exact by definition — no rounding decisions were made to build the table, and no precision setting changes the numbers.

Seconds	Decimal minutes	Minutes and seconds
60	1.0	1 min 0 s
90	1.5	1 min 30 s
120	2.0	2 min 0 s
300	5.0	5 min 0 s
600	10.0	10 min 0 s
900	15.0	15 min 0 s
1,800	30.0	30 min 0 s
3,600	60.0	60 min 0 s (1 hour)
10,000	166.67	166 min 40 s

The top row is the definition itself: 60 seconds = 1 minute exactly. The 3,600-second row is the boundary worth memorizing — 3,600 seconds = 60 minutes = 1 hour, which is also the divisor that skips the minutes step entirely when jumping straight to hours. MultiCalculators lists the same landmark values in its common-values table, including 90 s = 1.5 min and 3,600 s = 60 min.

The 10,000-second row shows the two formats diverging: 10,000 ÷ 60 = 166.67 decimal minutes, which is 166 minutes 40 seconds in remainder form. Round numbers like this appear in server timeout settings, stress-test durations, and some regulatory holding periods.

Decimal Minutes vs. Minutes and Seconds: Which Answer Do You Need?

Decimal minutes (7.5 min) and minutes-and-seconds (7 min 30 s) are two representations of the same division, and mixing them up is the most common mistake in this conversion. A value like “7.5” means seven and a half minutes; a value like “7:30” means seven minutes and thirty seconds. They describe the same duration, but writing one where the other is expected produces answers that are wrong by a factor that is not obvious at a glance.

Match the format to the use case. Decimal minutes suit billing, rates, and any downstream arithmetic — you can add, multiply, and average decimal minutes directly. Minutes and seconds suit clocks, timers, media duration, and anything a human will read aloud, because they map onto how displays and stopwatches actually present time.

Decimal minutes: 450 seconds = 7.5 minutes

Decimal minutes come from the plain division with no further processing: 450 ÷ 60 = 7.5. The fractional part is a true fraction of a minute, so 0.5 means half a minute. Brighterly states the result the same way — 450 seconds ÷ 60 = 7.5, meaning 7 minutes 30 seconds — showing both forms side by side, which is the clearest way to present the answer.

Minutes and seconds: floor + modulo (200 s = 3 min 20 s)

The remainder form uses two operations. Whole minutes = floor(seconds ÷ 60); remaining seconds = seconds mod 60. For 200 seconds: floor(200 ÷ 60) = 3 minutes, and 200 mod 60 = 20 seconds, giving 200 seconds = 3 minutes 20 seconds. MultiCalculators lays out this floor-and-modulo method with the identical 200-second example. A second check: 450 s → floor(450/60) = 7 min, 450 mod 60 = 30 s → 7 min 30 s.

One arithmetic note for readers checking the math itself: Brighterly’s conversion guide carries a named reviewer credential — Jessica Kaminski, who holds a BSc and a Master’s degree in Mathematics — and the page was updated September 30, 2026.

Timecode is not decimal seconds

In SMPTE timecode the notation runs HH:MM:SS:FF, where FF is a count of frames, not a decimal fraction of a second. Treating that final field as decimal seconds produces wrong runtimes in video and audio work — a distinction MultiCalculators flags directly, noting the frame count after the last colon is not a decimal fraction of a second. Where an unambiguous duration string is needed in data or documentation, ISO 8601:2019 provides one: 3 minutes 20 seconds is written PT3M20S, which cannot be confused with a decimal value.

Seconds to Minutes Calculator, Spreadsheet, and Code

Many people searching this term just want the answer, not the arithmetic. A seconds to minutes calculator returns both formats at once — decimal minutes and minutes-and-seconds — so the user does not have to decide. Keep a converter near the top of the page for that audience, and use the implementations below when the number is recurring or the conversion has to be automated.

In a spreadsheet (Excel and Google Sheets)

With seconds in cell A1, this single formula returns the label-ready remainder form:

=INT(A1/60)&" min "&MOD(A1,60)&" s"

With A1 = 200, the output is 3 min 20 s. INT performs the floor division and MOD extracts the remainder — the same two operations described in the previous section, expressed as spreadsheet functions.

In code: floor division and modulo

In virtually any language, whole minutes are seconds // 60 (integer floor division) and the remainder is seconds % 60. This is the same floor-and-modulo pair, and it is the safest implementation because neither operation introduces floating-point error.

A related developer gotcha involves a different factor. API timeouts and cache TTLs are often specified in seconds while libraries expect milliseconds. Five minutes is 300 seconds, which is 300,000 milliseconds — so the trap is the ×1,000 step, not the ÷60, and always checking which unit a function expects prevents it. The same risk applies to Unix timestamps, which are seconds since the epoch and are routinely misread as milliseconds; sorting or differencing them with the wrong unit skews results by a factor of 1,000.

Going the Other Way: Minutes to Seconds, Hours, and Days

The reverse operation is minutes × 60 = seconds, and it belongs beside the ÷60 formula so the page works in both directions. Five minutes × 60 = 300 seconds; 30 minutes × 60 = 1,800 seconds.

Above minutes, the same base-60 relationship chains upward. 3,600 seconds = 60 minutes = 1 hour, which means dividing seconds by 3,600 skips the minutes step entirely — a shortcut that is faster for large inputs. One step further, 86,400 seconds = 1,440 minutes = 24 hours, produced by chaining the relationship three times (60 × 60 × 24). Brighterly derives the day figure the same way and was updated September 30, 2026; the same 86,400-second day anchor appears in Vicaya’s conversion reference and in Tonton Tools’ time converter.

Scale intuition helps large raw-second values mean something. One million seconds is only about 11.6 days, while one billion seconds is roughly 31.7 years — a comparison Tonton Tools presents as a way to feel the difference between the two magnitudes.

Why Are There 60 Seconds in a Minute?

The direct answer is that 60 is a convention inherited from sexagesimal (base-60) counting, not a physical constant. The length of a second is fixed by atomic physics, but the decision to count 60 of them per minute is a definition humans agreed on.

The origin layer is Babylonian base-60 mathematics, which was adopted by Hellenistic astronomers for angular measurement and time and carried into the degree–minute–second structure. The convenience argument reinforced it: 60 divides evenly by 2, 3, 4, 5, 6, 10, 12, 15, 20, and 30, which makes fractional splits of an hour clean.

The subdivision layer is documented much later. Al-Biruni first subdivided the hour sexagesimally into minutes, seconds, thirds, and fourths in 1000 CE. Roger Bacon, writing in Latin in 1267, defined divisions of time between full moons using hours, minutes, seconds, thirds, and fourths. Jost Bürgi was the first clockmaker to add a minute hand, on a clock built for astronomer Tycho Brahe in 1577, and the minute hand reached watches only after Thomas Tompion’s hairspring in 1675. The modern layer arrived with the International System of Units, which accepts the minute as a non-SI unit used with the system and fixes it at exactly 60 seconds in the SI Brochure — converting a long-standing convention into an exact standardized factor.

The takeaway that matters for the rest of this page: because 60 per minute is a definition rather than a measurement, the conversion factor is permanently fixed and cannot drift when a source is updated.

Where Seconds-to-Minutes Conversion Shows Up in Real Life

This query isn’t just a homework question. Developers, video and audio editors, payroll and billing staff, coaches, and lab users all convert raw seconds into minutes regularly, and each group needs a different output format.

Sports timing. Race splits and results are published in raw seconds, so a marathon duration of 7,374 seconds reads as 2 h 2 min 54 s — the figures MultiCalculators uses in its sports-timing example, presented here as an illustration of the arithmetic rather than as an official record.

Billing and payroll. Mixed durations collapse into one billable decimal number. A task logged at 2 hours 15 minutes 45 seconds becomes 120 + 15 + 0.75 = 135.75 total minutes, the exact output SavvyCalculator’s calculator returns for that worked example.

Video and audio production. Clip runtimes and render times arrive in seconds, which is precisely where the decimal-versus-timecode confusion described earlier causes practical damage to timelines.

Science, cooking, and everyday timers. Reaction times, pulse rates, microwave and oven timers, and elapsed-time logs all call for quick conversion between seconds and minutes. For everything downstream of an hour, chain directly to ÷3,600 or use the 86,400-second day anchor rather than converting twice.

Conclusion

Converting seconds to minutes is a single exact division — minutes = seconds ÷ 60 — and the only real choice is which output format you need: decimal minutes or minutes and seconds. Use the ÷60 formula for quick mental math, the landmark table when you need a common value at a glance, and a time unit converter, spreadsheet formula, or code one-liner when the number is messy or recurring. For anything involving hours or days, skip the intermediate step: divide by 3,600 for hours, or work from the 86,400-second day. Because the factor is an SI definition, no result on this page will ever change.

FAQ

How many minutes is 60 seconds?

Exactly 1 minute. This is the definition itself, not a rounded result: 60 ÷ 60 = 1 with zero remainder. There is no uncertainty in the answer, and no precision setting changes it.

How many minutes is 3,600 seconds?

3,600 ÷ 60 = 60 minutes, which is exactly 1 hour. This is why dividing a number of seconds by 3,600 returns hours directly, skipping the intermediate minutes step entirely.

How do I convert seconds to minutes and seconds (remainder form)?

Whole minutes = floor(seconds ÷ 60); remaining seconds = seconds mod 60. For example, 200 s → 3 min 20 s, and 450 s → 7 min 30 s. In a spreadsheet with seconds in A1, use =INT(A1/60)&" min "&MOD(A1,60)&" s".

How many seconds are in a day?

86,400 seconds — 60 seconds × 60 minutes × 24 hours. That is 1,440 minutes, or 24 hours. The figure is commonly used for cache lifetimes and scheduling calculations.

What is 10,000 seconds in minutes?

10,000 ÷ 60 = 166.67 decimal minutes. In remainder form that is 166 minutes 40 seconds. Round values like this often appear in server timeout settings and stress-test durations.

Is a minute always exactly 60 seconds — can it ever be 59 or 61?

Under the SI definition, yes: 1 minute = 60 seconds, always. The one documented exception is UTC, where a positive leap second can make a clock minute 61 seconds long; negative leap seconds, which would produce a 59-second minute, have never been used.

Why are there 60 seconds in a minute?

It comes from sexagesimal (base-60) counting in ancient Babylonia, later adopted by Hellenistic astronomers for angles and time. The SI Brochure now fixes 1 min = 60 s exactly — the minute is a non-SI unit accepted for use with the SI — turning the convention into an exact, permanent standard. The full history is covered in the section above.

2026年10月16日

SVG to GIF: Convert Static and Animated SVGs Free

To convert SVG to GIF, upload your .svg file to a free browser-based SVG to GIF converter, pick GIF as the output, then set the dimensions, colors (2–256), dithering and transparency before you download. If your SVG is animated, render the frames first — most converters only export the first static frame.

How to Convert SVG to GIF Online in 3 Steps

The most common SVG to GIF mistake isn’t a bad conversion. It’s downloading the wrong file type. Plenty of pages that call themselves “SVG converters” are actually built around a different output format. The CoolUtils SVG to JPG page, for example, is titled and marketed as a JPG converter. GIF shows up only as one option in a dropdown list, sitting alongside JPEG, BMP, TIFF, ICO, PNG and PDF. Click convert without checking the format selector, and you’ll end up with a .jpg — something you may only notice after the download.

The workflow below is short, but each of the three steps locks in a decision you can’t undo later.

Step 1: Upload the .svg and Make Sure GIF Is the Output Format

Drop your .svg file into the converter’s upload area. Some tools also accept the compressed .svgz variant, which CoolUtils lists as an associated SVG file extension.

The key move here is choosing the format yourself. Open the output format control and select GIF — don’t assume the tool will guess what you want from the input. On several interfaces, GIF is tucked into a secondary “More formats” menu while the default stays on JPG or PNG. Before you hit convert, check two things: the file you uploaded really ends in .svg, and the format field says GIF, not JPEG.

Step 2: Set Dimensions, Colors, Dithering and Transparency

GIF is not a neutral container. What you set here decides how the image looks, and no later step can bring back what you leave out.

A free browser converter like ToFormat’s SVG to GIF tool gives you a typical set of controls: output dimensions, number of colors (2–256), a dithering toggle, and a transparency color. For animated output, it adds frame delay and loop count. Those six values are the whole quality surface of the conversion.

Set the pixel dimensions to match where the GIF will actually appear, pick a color count that suits the artwork, and decide whether you need a transparent background at all. Section 4 walks through the trade-offs behind each setting.

Step 3: Download the .gif and Verify It Before You Ship It

Save the file, open it right away, and check two things before you use it anywhere.

First, does it animate? If the source SVG had an animation and the result sits frozen on a single frame, you’ve hit the static-snapshot limitation described in section 3, and you’ll need a different workflow. Second, where does the tool say your file goes? Retention policies vary a lot and are worth writing down. ToFormat states that files auto-delete after 10 minutes. The CoolUtils page says files are deleted within 24 hours in one section, but another section on the same page says both the SVG and the result are deleted automatically after conversion. That’s a good reason to verify any retention claim on the live page instead of trusting your memory.

A 30-second self-check before you ship the GIF:

Are the shape’s edges clean, or is there a white halo or hard stair-stepping?
Does a gradient show visible bands instead of a smooth ramp?
If it should be animated, does it actually move — and does it loop the way you want?

If something looks off, fix it in the parameters — running the same conversion again with the same settings won’t help.

Why the Result Looks Different: Rasterization and GIF’s Four Hard Limits

Most converters don’t tell you what they’re about to give up. This section turns the format mechanics into what you’ll actually see, so you can predict the outcome instead of discovering it after you download.

Rasterization Picks a Pixel Size You Can’t Undo

SVG is an XML-based vector format. It describes an image with drawing commands — paths, shapes, strokes, fills, text — rather than pixels. According to the MDN image format guide, SVG has no maximum dimension limit because it isn’t bound to a pixel grid.

GIF is the opposite: a raster format where every pixel holds a fixed value. So converting SVG to GIF requires rasterization — rendering the vector at one specific width and height so it becomes a pixel image. As reaConverter’s technical note on its SVG to JPG page puts it, SVG “describes geometry rather than pixels, so it has no inherent resolution.” The size you choose during conversion “is final: enlarging the JPG afterwards will not recover the sharpness.”

That’s the first decision you can’t reverse. Pick the output size as if it were permanent — because it is.

256 Colors, One Transparent Index, and Dithering Artifacts

GIF’s color model is behind most visual complaints. Per MDN, GIF is an 8-bit indexed color format: each pixel is a single 8-bit value pointing into a palette of 24-bit colors, and the palette length is always a power of two — 2, 4, 8, 16, 32, 64, 128 or 256 entries. There’s no true color mode.

For a flat two-tone icon, 256 entries are more than enough. For an SVG with a gradient fill, a drop shadow, or an embedded raster image, 256 colors aren’t enough — and the missing values show up as color banding, visible steps where the source had a smooth transition. To simulate more colors than the palette holds, MDN notes that dithering is generally used. That’s the trade: banding, or noise.

Transparency works the same way. MDN states that GIF pixels “are opaque, unless a specific color index is designated as transparent, in which case pixels colored that value are entirely transparent.” There’s no alpha channel — no partial transparency. This matters because vector renderers draw smooth, antialiased edges built from semi-transparent pixels. GIF can’t store a half-transparent pixel, so every edge pixel has to resolve to either fully opaque or fully transparent. What you see is a white or colored fringe around curved shapes, or a jagged edge where the antialiasing used to be.

Dithering isn’t a fix — it’s a trade. Turn it on when a gradient shows obvious banding and the noise texture is acceptable. Leave it off for flat icons, logos and line art, where it adds grain without solving anything.

MDN’s guidance for the format is blunt: GIF is a “good choice for basic images and animations,” but “converting full color images to GIF can result in unsatisfactory dithering.” MDN recommends preferring PNG for lossless and indexed still images, and considering WebP, AVIF or APNG for animation sequences. Worth remembering before you commit to GIF at all.

The 65,536-Pixel Ceiling and File Size Trade-offs

GIF’s maximum dimensions are 65,536 × 65,536 pixels, according to MDN. For icons, logos and UI assets, that ceiling doesn’t matter. For large print-oriented artwork, it’s a real constraint that pushes you toward a different format.

The bigger practical issue is size. GIF uses LZW, a lossless compression method, so there’s no quality dial you can turn down to shrink the file. The only levers are dimensions, palette size, and — for animation — frame count and frame rate. GIF was also one of the first two graphics formats supported by HTML, alongside XBM. That’s exactly why it survives: compatibility, not efficiency.

Four decisions that follow from these limits:

If your SVG is a flat icon, keep the color count low and dithering off — the limits barely apply.
If your SVG has gradients or shadows, start with a high color count, then turn dithering on only if banding shows up.
If your SVG needs a transparent background over a colored page, expect an edge halo and consider a matte color instead.
If your SVG needs smooth transparency, small file size, or more than 256 colors, GIF is the wrong target format — see section 6.

How to Convert an Animated SVG to an Animated GIF (Without Losing the Motion)

Converting a static SVG is a one-click job. Converting an animated one isn’t — and this is where most SVG to GIF instructions stop short.

Why Some Converters Only Capture the First Frame

SVG animation is a stable, widely supported feature. The MDN <animate> reference documents the element as Baseline widely available, supported across browsers since January 2020, and standardized in SVG Animations Level 2 (the MDN page was last modified September 11, 2026).

The gap is on the tool side. In its own FAQ, CoolUtils states plainly that JavaScript and CSS animations are “rendered in their initial state,” and that the converter “outputs a static snapshot of the SVG as it appears before any animations run.” It adds that dynamic SVG effects are not captured.

Framing matters here. That’s one vendor describing its own online converter — not a statement about every SVG tool, since some converters do handle animation. But it does explain the most common complaint in this workflow: you convert an animated SVG and get back a still image. The format supports motion; the pipeline doesn’t.

So before you invest time in a converter, test it with a known animated SVG and check whether the output moves. If it doesn’t, no setting in the interface will fix it.

Step A: Render SMIL and CSS Animations into a PNG Frame Sequence

Animated GIF needs a sequence of raster frames. Animated SVG produces continuous motion at render time. Something has to bridge the two, and that bridge is a PNG frame sequence.

Three routes work:

Headless browser screenshots. Drive a browser programmatically, step the animation clock to a specific timestamp, capture a screenshot, and repeat for each frame. This gives you exact control over frame timing and output size.
Browser rendering with timed capture. Open the SVG in a browser tab, play the animation, and grab screenshots at fixed intervals. Simpler to set up, but less precise on timing.
Desktop editors. Open the SVG in Inkscape, Photoshop or GIMP and export frames one at a time. Slowest of the three, but no scripting needed, and you can inspect each frame.

Whichever route you pick, set the raster output size before exporting. Every frame inherits the rasterization decision from section 2 — and so does the final GIF.

Step B: Assemble the Frames with ffmpeg or ImageMagick

Once you have numbered PNG frames, assemble them with a palette-based encoder. Here’s why: because of the 256-color limit, a naive conversion re-quantizes every frame on its own, which causes flicker. A two-pass approach builds one palette from the whole sequence and applies it to every frame.

With ffmpeg, that’s the standard palettegen / paletteuse pair:

ffmpeg -i frame_%04d.png -vf "palettegen" palette.png
ffmpeg -i frame_%04d.png -i palette.png -lavfi "paletteuse" output.gif

Add a max-colors value to the first pass if you want a smaller palette, and adjust frame rate and loop behavior on the second pass.

With ImageMagick, the equivalent controls are -colors for palette size, -delay for frame timing, -loop for repeat count, and -dispose to control how each frame replaces the previous one.

Starting parameters that work for most icon- and logo-style animations:

Frame rate: 12–25 fps is enough. Higher rates multiply file size without adding visible smoothness for this kind of artwork.
Color count: 32–128. Match it to the complexity of the artwork instead of defaulting to 256.
Loop count: 0 means infinite; a finite number gives viewers an exit.
Dispose method: matters for animations where frames don’t repaint the full canvas — the wrong setting leaves trails.

After assembly, go back to section 2 and check the result against all four GIF limits. Animated files grow fast — if the GIF is too large, reduce dimensions or cut the frame rate before touching anything else.

If you’d rather skip the command line, there’s a limited middle route: ToFormat lets you select multiple SVGs — up to 20 — and combine them into a single animation with controllable frame delay and loop count. That’s a different operation from converting one animated SVG, but it covers cases like building a frame-based sequence from separately drawn SVG files.

Accessibility: Flashing Frames and prefers-reduced-motion

Per the MDN <animate> documentation, blinking and flashing animation can be a problem for people with cognitive conditions such as ADHD, and certain kinds of motion can trigger vestibular disorders, epilepsy, migraine and scotopic sensitivity.

MDN’s recommended mitigations include giving users a way to pause or disable the animation, and honoring the reduced motion media query (prefers-reduced-motion) or the equivalent Sec-CH-Prefers-Reduced-Motion client hint. A GIF runs on its own with no pause control, so the equivalent step is to check the output before publishing: reduce flashing frequency, keep the loop short, or offer a static version alongside it.

Output Settings That Actually Matter: Size, Colors, Dithering, Transparency, Delay and Loop

Every control in the converter maps to a visible consequence. Think of these as trade-offs, not labels.

Color Count and Dithering: Fixing Banding Without Adding Noise

Color count is limited by GIF’s 8-bit indexed palette, which tops out at 256 entries, per MDN. Within that ceiling, match the count to the artwork: flat icons and simple logos generally hold up well at 16–32 colors. Anything with a gradient, soft shadow or photographic content should start at 128 and only go to 256 if the result still bands. Because the palette length is always a power of two, intermediate values like 100 get rounded to 64 or 128 anyway.

Dithering hides banding by scattering pixels from adjacent palette entries. The cost is grain. MDN notes that dithering is generally used to simulate more than 256 colors, and separately warns that converting full-color images to GIF can produce unsatisfactory dithering — so it’s a mitigation, not a cure. Turn it on only when you can see banding; turn it off for flat graphics, where it adds visible noise for no benefit.

Ordered (pattern-based) dithering tends to produce a more uniform texture than random or error-diffusion methods, which matters for small icons where individual pixels are visible.

Transparency and the Edge Halo Problem

GIF stores exactly one transparent color index — not an alpha channel. Every pixel is either fully opaque or fully transparent.

SVG artwork, however, is antialiased: the renderer blends edge pixels between the shape color and the background so curves look smooth. When those blended pixels hit GIF, each one has to pick a side. You’ll see it as a light fringe around dark shapes on a colored page, or ragged edges around circles and text.

Three practical options:

Composite onto a matte. Add a solid background rectangle to the SVG in the same color as the page the GIF will sit on, so the antialiased edges blend into something real.
Reduce edge complexity. At small output sizes, simple straight-edged shapes survive the transparency limit better than curved or stroked artwork.
Avoid transparency entirely. If the destination has a predictable background, a solid background is often cleaner than a bad transparent one.

Also worth knowing: in a converter that exposes a “transparency color” setting, you’re choosing which palette entry becomes the transparent index. If your artwork happens to contain that color, those pixels will vanish too.

Frame Delay, Loop Count and Shrinking the File

Frame delay is usually expressed in hundredths of a second per frame in the GIF format itself, and many interfaces show milliseconds. Delay values that are too small can be clamped by some players, which makes a carefully tuned animation play back at a different speed than you intended. Test in the actual destination — email client, chat app, browser — not just in a preview window.

Loop count of 0 means infinite repetition. A finite count lets a long or detailed animation stop after a few cycles instead of looping forever.

File size responds best to a specific order of operations:

Reduce output dimensions — this is the largest single lever.
Reduce the color count to the smallest palette that still looks right.
Cut the frame rate or drop frames.
Adjust dithering last, since it has a modest size effect relative to the first three.

A ToFormat conversion, for instance, exposes dimensions, a 2–256 color range, dithering, a transparency color, plus frame delay and loop count for animation — a fair checklist of everything you can control, and everything that affects the result.

Which SVG to GIF Converter Should You Use? Online, Desktop or Browser-Local

There’s no single best converter, because the deciding factors are file size limits, whether your file leaves your machine, animation support, and batch capability. Compare on those criteria, not on marketing copy.

Converter Comparison Table (File Limits, Upload Policy, Animation Support)

Limits and retention statements below were checked on 2026-10-03 and are vendor self-descriptions. Treat the live page as authoritative — these values change.

Tool	Type	Stated input limit	Where files go	Animation	Notes
ToFormat	Browser, free	Not stated in the page summary	Uploaded; auto-delete in 10 minutes	Combines up to 20 SVGs into one animation; frame delay and loop count	2–256 colors, dithering, transparency color, ZIP download
CoolUtils online	Browser, free	50 MB	Uploaded; page says deletion within 24 hours in one section and automatic deletion after conversion in another	Only the initial static state, per its own FAQ	Page updated 6 September 2026; GIF is one of several output formats
IntoConvert	Browser, free	150 MB	Uploaded; deleted when the download is sent, not stored	No SVG animation path documented	Publishes public conversion guides; ffmpeg-based GIF workflows documented for video
Innerscene	Browser, free	200 MB (adapts to device memory)	Never uploaded — parsed and exported in the browser tab	Not documented for animation	No signup, no watermark; useful for NDA or client material
reaConverter Lite	Desktop, Windows 10/11, free	No limit stated	Local — nothing uploaded	Not documented for SVG animation	Batch, right-click conversion, offline; vendor page lists an average user rating of 4.8, last updated September 12, 2026, v8.0.250; the page’s primary target is SVG → JPG
Svgtopng.com	Browser, free	Up to 20 files at once	Uploaded	Not documented	Returns single files or a ZIP; also handles EPS and JPG
CloudConvert	Browser / API	Not stated	Uploaded	Not documented	Supports 200+ formats and offers APIs for bulk conversion
Canva	Browser	Not stated	Uploaded	Not documented	Conversion plus built-in editing tools

A note on what this table can and can’t tell you: most of these pages describe themselves, and the animation column reflects what each vendor documents, not exhaustive testing. CoolUtils and reaConverter are both built mainly around static image conversion, so if animation is your requirement, verify before committing.

Which Option Fits Which User

One-off static icon or logo, nothing sensitive: any free online converter works. Pick one whose retention policy you actually read.
Animated SVG: skip the general-purpose online converters unless the tool explicitly documents animation support. Plan on the frame-sequence route in section 3.
Confidential or client-restricted artwork: use a browser-local tool such as Innerscene, or a desktop converter such as reaConverter Lite. Nothing leaves your machine.
Hundreds of icons with identical settings: use a desktop batch converter or a command-line pipeline. Online tools cap out — ToFormat at 20 files, Svgtopng.com at 20 files per upload — which is why section 7 exists.

Server-Side Conversion and MIME Types

If you’re converting on a server rather than in a browser, two headers matter. Per MDN, SVG’s MIME type is image/svg+xml and GIF’s is image/gif. Serve the source with the correct type so the renderer treats it as an image, and set the output Content-Type to image/gif — a GIF served as application/octet-stream will download instead of display, and one served as image/svg+xml will fail to render.

Check caching and compression policy alongside the headers. SVG source compresses well in transit or as .svgz, while GIF’s LZW data doesn’t benefit much from further compression, so caching is the more useful lever for repeated requests.

When You Actually Need a GIF — and When APNG or WebP Is the Better Answer

GIF’s 256-color palette and one-bit transparency are real costs. The question is whether your target environment leaves you any choice.

Scenarios Where GIF Is Still the Only Option

These are the environments that reject SVG outright — which is where GIF earns its place. The CoolUtils SVG to JPG page lists several: most email clients don’t render SVG images inline; inserting SVG into older Office versions produces unpredictable results; Twitter, LinkedIn and Instagram reject SVG uploads; and some CMS media libraries only accept raster formats in their uploader.

In each of those cases, the format isn’t a preference — it’s a compatibility floor. GIF’s historical support across Chrome, Edge, Firefox, IE, Opera and Safari, plus its status as one of the first two graphics formats supported by HTML, is exactly why it still works where newer formats don’t.

GIF vs APNG vs WebP: A Neutral Comparison

MDN’s format guide gives GIF a qualified endorsement: “Good choice for basic images and animations. Prefer PNG for lossless and indexed still images, and consider WebP, AVIF or APNG for animation sequences.”

The technical differences explain that recommendation:

	GIF	APNG	WebP	AVIF
Color depth	8-bit indexed, max 256 colors	Multiple color depths supported	Higher color depths than PNG/JPEG	Higher color depths, HDR, wide gamut
Transparency	Single transparent color index	Full alpha	Alpha supported	Alpha supported
Max dimensions (MDN)	65,536 × 65,536	2,147,483,647 × 2,147,483,647	16,383 × 16,383	2,147,483,647 × 2,147,483,647
Compression	Lossless (LZW) only	Lossless	Lossy and lossless	Lossy and lossless
Browser support	All versions of Chrome, Edge, Firefox, Opera, Safari	Chrome, Edge, Firefox, Opera, Safari	All versions of Chrome, Edge, Firefox, Opera, Safari	Chrome, Edge, Firefox, Opera, Safari

Two notes on performance. MDN states that lossy WebP images are on average 25–35% smaller than JPEG images of visually similar compression levels, and that lossless WebP images are typically about 26% smaller than the same images in PNG format. For AVIF, MDN reports that lossy AVIF images run roughly 50% smaller than JPEG at comparable visual quality, and cites a median compression advantage over WebP of about 50% versus 30% on the same JPEG set. APNG’s specific edge over GIF, per MDN, is that it supports a variety of color depths “whereas animated GIF supports only 8-bit indexed color.”

The judgment rule: if the destination environment accepts anything, don’t use GIF — APNG, WebP or AVIF will give you better transparency and smaller files, and MDN recommends providing a <picture>-based fallback where browser support isn’t universal. If the destination only accepts GIF, use GIF and push the four limits from section 2 as hard as they’ll go.

Batch Converting a Folder of SVG Icons to GIF

Icon libraries hit online converter limits fast. ToFormat caps a combined animation at 20 SVG files, and Svgtopng.com accepts up to 20 files at once — fine for a handful of assets, not for a 300-icon design system.

Desktop route. A batch-capable desktop converter processes an entire folder in one pass. reaConverter Lite offers batch conversion, right-click conversion from Windows Explorer, and fully offline processing, with a vendor-stated average user rating of 4.8 as of the September 12, 2026 page update. Alternatively, export PNGs from Inkscape’s command line and assemble them in a batch step.

Command-line route. ImageMagick’s mogrify and convert can loop over a directory and apply identical settings to every file — -resize for output dimensions, -density for render resolution, and -colors for palette size. For animated sequences, an ffmpeg palette pipeline run per file keeps the encoding consistent across the set.

Consistency rules for icon sets. Lock these in before you start the batch, not after: one output pixel size, one color count, one dithering setting, one naming convention. Mixed palettes and mixed edge treatment are immediately visible when a set of icons sits side by side in a UI — and fixing them one file at a time costs far more than setting them once across the folder.

Conclusion

SVG to GIF is really two different jobs. Converting static art is a one-click rasterization bounded by decisions you make once — output size, color count, dithering, transparency. Converting an animated SVG is a pipeline: render frames, then assemble them with a shared palette, because most simple converters hand you only the first frame.

Start by testing whether your converter preserves motion at all. If it doesn’t, go the frame-sequence route. If it does, tune in the order that actually moves file size: dimensions first, then color count, then frame rate, and dithering last. Use a local or desktop tool when the files are sensitive or the set is large. And before you commit, check section 6 — if the destination accepts APNG, WebP or AVIF, GIF is rarely the right answer.

FAQ

Can I convert an animated SVG to an animated GIF for free, or do I need desktop software?

Free online conversion is possible, but only if the tool genuinely supports animation. Some converters document that they output a static snapshot of the animation’s initial state — CoolUtils states this about its own converter — so verify with a test file. The free fallback is to render PNG frames in a browser and assemble them with ffmpeg’s palettegen/paletteuse pair.

Why did my SVG lose its transparent background, or look dithered, after converting to GIF?

GIF has no alpha channel. Per MDN, pixels are opaque unless one specific palette color index is designated transparent, so the antialiased semi-transparent edges of an SVG must resolve to fully opaque or fully transparent — producing a halo or jagged edges. Dithering is typically the converter’s automatic attempt to cover 256-color banding, and it adds visible grain.

Is my SVG file uploaded to a server when I convert it to GIF online?

It depends on the tool. Most online converters upload your file; a few, such as Innerscene, state that parsing and export run entirely in the browser tab and nothing is transmitted — ImageLean’s SVG to GIF converter is built on the same browser-based privacy model. Retention policies also vary, and the same page can contain inconsistent statements — the CoolUtils page describes both 24-hour deletion and deletion immediately after conversion. Check the live page for anything sensitive.

Can I convert GIF back to SVG?

Not in any real sense. GIF is a raster bitmap and SVG is vector, so the geometry is lost during rasterization — it cannot be recovered. Automatic tracing produces only an approximation, with distorted edges and approximated colors. If you need a scalable version, go back to the original SVG source file rather than reconstructing one from a GIF.

Is GIF still a good choice for web animation in 2026, or should I use APNG or WebP instead?

Where the environment is unconstrained, APNG, WebP and AVIF generally deliver smaller files and better transparency. MDN’s format guide advises preferring PNG for lossless and indexed still images and considering WebP, AVIF or APNG for animation sequences. GIF’s remaining advantage is the broadest historical compatibility — email clients, social platforms and older software — so use it there and choose a newer format elsewhere.

How do I batch-convert a whole folder of SVG icons to GIF offline?

Online tools cap uploads — ToFormat combines up to 20 SVGs, and Svgtopng.com accepts up to 20 files at once — so a full icon library will exceed them. Use a desktop batch converter with offline processing, or export PNGs from Inkscape’s command line and process the directory with ImageMagick or ffmpeg, applying identical size, color count and dithering settings to every file.

2026年10月16日

Cron Expression Syntax: Fields, Operators, and Dialects

Cron expression syntax is built from five space-separated fields — minute, hour, day of month, month, and day of week — that tell a scheduler when to run a job. Each field can hold a value, list, range, step, or *, so 0 9 * * 1-5 runs at 09:00 every weekday.

What Is Cron Expression Syntax?

Cron expression syntax is the compact string format a scheduler uses to decide whether the current clock time matches a schedule. A cron expression describes a set of times, not a countdown. The scheduler compares the current minute, hour, day, month, and weekday against the expression; when every field matches, the command runs.

That difference matters: cron is not an interval timer. Writing */5 in the minute field does not mean “wait five minutes and then run again.” It means “match minute values 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, and 55.” Cron has no memory of the last run and does not measure elapsed time, so the expression is a pattern-matching rule, not a stopwatch. Wikipedia makes the same point plainly: cron is a mere pattern-matcher, not a frequency counter (Wikipedia).

A standard cron line has five time-and-date fields followed by the command to execute. The field order never changes: minute, hour, day of month, month, day of week. System crontabs add a sixth column for the user, and some non-Unix schedulers put seconds first or a year last, but the traditional five-field form is still the baseline. This article focuses on writing the expression correctly. Execution failures, permissions, logging, and notifications are separate operational concerns that come into play only after the schedule itself is right.

Anatomy of `0 9 * * 1-5`: every token, decoded

The expression 0 9 * * 1-5 breaks down from left to right. The first field, 0, means minute zero. The second field, 9, means the ninth hour on a 24-hour clock, or 09:00. The third field, *, means every day of the month. The fourth field, *, means every month. The fifth field, 1-5, means Monday through Friday, assuming Sunday is 0 or 7 in the dialect being used. The job fires at 09:00 on weekdays only. In a system crontab, a user column would sit between the fifth field and the command, which is one reason copy-pasting crontab lines between files can shift the meaning.

The Five Fields: Minute, Hour, Day of Month, Month, Day of Week

The five fields are the core reference for cron expression syntax. Each field accepts a limited set of values, and some also accept three-letter names.

Position	Field	Allowed values	Name aliases	Notes
1	Minute	0–59	None	Smallest unit in standard cron
2	Hour	0–23	None	24-hour clock, no AM/PM
3	Day of month	1–31	None	Some dialects add `?`, `L`, `W`
4	Month	1–12	`JAN`–`DEC`	Names may not be supported everywhere
5	Day of week	0–7 or `SUN`–`SAT`	`SUN`–`SAT`	Sunday numbering varies by dialect

In standard Unix cron, both 0 and 7 mean Sunday, while 1 through 6 mean Monday through Saturday. That convention is not universal. Quartz, AWS EventBridge, Cloudflare, and some other dialects use 1 for Sunday. A copied expression can still parse but run on a different day.

Cron has no concept of a default value. You cannot leave a field blank, and a blank field does not inherit a fallback. The wildcard * is how you say “every value in this field.” Quartz-style schedulers add ? to mean “no specific value,” which helps avoid the day-of-month and day-of-week conflict described later. That difference is often the first sign that a five-field expression is being read by a six-field parser.

Field-order mistakes are costly because they usually produce a valid expression instead of an error. Swap the month and day-of-month fields, and a monthly job can become a daily job on the wrong date. Swap the hour and day-of-month fields, and a 09:00 task can become one that runs on the ninth day of each month. The scheduler does not warn you. It just matches a different pattern.

Value ranges, name aliases, and the values each field rejects

Each field rejects values outside its range, but when that happens varies. Standard cron usually rejects an out-of-range number when the crontab is loaded, while some managed schedulers validate only after deployment. Month names such as JAN and DEC, and weekday names such as MON and SUN, are accepted by many Vixie-derived implementations and are case-insensitive. They are not part of the portable baseline. Vercel’s documentation says Vercel cron jobs do not support alternative expressions like MON, SUN, JAN, or DEC (Vercel, last updated September 16, 2026).

Day-of-week aliases are also where Sunday numbering becomes visible. Cloudflare Workers documentation lists weekdays as 1-7 with case-insensitive three-letter abbreviations such as MON and fri (Cloudflare, last updated September 4, 2026). Quartz and AWS EventBridge also start the week at 1 for Sunday. Unix crontab, Kubernetes CronJob, Jenkins, GitHub Actions, and Spring accept 0 for Sunday and usually also accept 7. A name alias is safer than a bare number when the dialect supports it, but not when the platform rejects aliases entirely.

Field-order mistakes that silently shift your schedule

A field-order mistake rarely causes a syntax error. It causes a different schedule. 0 0 1 * * means midnight on the first day of every month. Reorder it to 0 0 * 1 *, and it means midnight every day in January. The scheduler has no way to know which one you intended.

Two habits prevent most of these errors. First, read the expression aloud with the word “of” between fields, in this order: minute, hour, day of month, month, day of week. Second, check the plain-English translation in a cron expression parser before deploying. A parser that shows the next run times catches a shifted field immediately, because the next-run list no longer matches the cadence you wanted.

The Four Operators: * , – / and How They Combine

Four characters do nearly all the work in standard cron expression syntax: *, ,, -, and /. The asterisk means every allowed value. The comma builds a list. The hyphen defines an inclusive range. The slash defines a step.

Combinations are where the compact syntax becomes powerful. 1-30/5 applies a step of five to the range 1 through 30, producing 1, 6, 11, 16, 21, 26. 0,15,30,45 in the minute field equals */15 in that same field, because both select minutes 0, 15, 30, and 45. 5/15 starts at 5 and steps by 15 through the rest of the field, producing 5, 20, 35, 50. The slash does not create a timer. It selects points from the allowed values.

The highest-frequency standard schedule, * * * * *, runs every minute. According to JasperBernaers.com, that is 1,440 runs per day and 10,080 runs per week. Those numbers are a useful sanity check before deploying anything that runs every minute. A job that sometimes takes longer than sixty seconds can overlap with itself, which is why high-frequency schedules often need a lock or a concurrency policy.

Steps are not intervals: why `*/7` is not “every 7 minutes”

The step operator is the most common source of false expectations. */7 in the minute field selects minutes 0, 7, 14, 21, 28, 35, 42, 49, and 56. The next run after minute 56 is minute 0 of the following hour, only four minutes later. JasperBernaers.com documents this short-gap behavior: any step that does not evenly divide the field range produces an inconsistent final interval. Minutes divide evenly by 2, 3, 4, 5, 6, 10, 12, 15, 20, and 30. A step of 7 does not divide 60 evenly, so every hour has a short gap. If you need a true seven-minute cadence, standard cron cannot express it; you need a scheduler with second-level precision or an application-level loop.

Which Cron Syntax Are You Actually Writing? A Dialect Matrix

“Cron” is not one language. Before writing an expression, identify the scheduler. The same string can be valid, invalid, or valid with a different meaning depending on the platform.

Platform	Fields	Seconds	Sunday	`?`	`L` / `W` / `#`	Time zone default
Unix / Vixie crontab	5	No	0 or 7	No	No	Host local or `TZ=`
Kubernetes CronJob	5	No	0 or 7	No	No	UTC unless `spec.timeZone` set
Quartz	6 or 7	First	1	Required in one day field	Yes	JVM default unless set
Spring `@Scheduled`	6	First	0 or 7	Allowed	No	JVM default unless set
AWS EventBridge	6	No; year last	1	Required	Yes	UTC
Azure NCRONTAB	6	First	0	No	No	Service configuration
Cloudflare Workers	5	No	1–7	No	Yes	UTC
Jenkins	5	No	0 or 7	No	No; has `H`	Controller time zone
GitHub Actions	5	No	0 or 7	No	No	UTC
Vercel	5	No	0–6	No	No	UTC

The practical rule is to treat Linux/Vixie five-field cron as the baseline, then check how the target platform deviates. The biggest deviation is Sunday numbering. In Quartz and AWS EventBridge, Sunday is 1 and Saturday is 7. Copying 0 0 * * 1 from a Linux crontab into Quartz does not fail; it changes the run from Monday to Sunday. On a managed platform, that mistake can run for months before anyone notices.

Is Sunday 0, 1, or 7 in your dialect?

Unix crontab, Kubernetes CronJob, Jenkins, GitHub Actions, and Spring treat Sunday as 0, and most also accept 7. Quartz, AWS EventBridge, and Cloudflare treat Sunday as 1. Azure NCRONTAB uses 0 for Sunday and rejects 7. So the safe answer is not a number at all: if the dialect supports names, use SUN, MON, and so on. If it does not, confirm the numbering from the platform documentation before deploying. Vercel is a notable case where names are not supported, so a numeric day-of-week value must be checked against Vercel’s own 0–6 range (Vercel).

The six-field, seconds-first family: Quartz, Spring, Azure NCRONTAB

Quartz is the clearest example of a different dialect. It is a Java scheduler that uses six or seven fields, with seconds first and an optional year last. Broadcom’s Scheduler documentation, which uses Quartz cron, describes special characters *, ?, #, and #-#, and states that the day of week starts at 1 for Sunday (Broadcom TechDocs, last updated September 17, 2026). Spring @Scheduled uses six fields with seconds first. Azure Functions NCRONTAB also uses six fields with seconds first. Pasting a five-field expression into any of these is not a harmless mistake: the parser either rejects it or shifts every value one position to the right, which can make a daily job run sixty times more often.

What changed recently: OCPS 1.0 (2025) and 2026 vendor documentation

In 2025, the Open Cron Pattern Specification published OCPS 1.0, a formal specification of the Vixie cron dialect that codifies the five-field pattern and rules for previously ambiguous edge cases (Wikipedia). The specification is designed as a backward-compatible superset, with future versions planned to add predefined schedules, second-level precision, and advanced calendar modifiers. Its current role is clarification, not replacement. OCPS is a specification effort, not a runtime that a scheduler automatically follows. Platform behavior still comes from each vendor’s documentation.

That is why vendor documentation dates matter. Vercel’s cron jobs page was last updated September 16, 2026, and Cloudflare’s Cron Triggers page was last updated September 4, 2026. Broadcom’s Quartz-based Scheduler cron syntax page was last updated September 17, 2026. When a platform says Sunday is 1, or that names are unsupported, or that only one day field may be set, the current documentation is the authority for that platform.

Common Cron Schedules You Can Copy — and What They Actually Run

These are standard five-field schedules that work in Vixie-style cron and most managed schedulers that accept five fields. The “runs per cycle” column is the check that catches a misread.

Expression	Meaning	Runs per cycle
`/5 * * *`	Every 5 minutes	12 per hour
`0 0 * * *`	Every day at midnight	1 per day
`0 9 * * 1-5`	Weekdays at 09:00	5 per week
`0 0 1 * *`	First day of every month at midnight	1 per month
`0 4 * * 0`	Every Sunday at 04:00	1 per week
`0 0 1 1 *`	Once a year on January 1	1 per year

A real operational schedule shows why spacing matters more than guessing. RE:NODE describes four ordered tasks for a game server: announce a restart at 04:40, save and back up at 04:50, restart at 05:00, and take a weekly locked backup on Sunday at 04:00. The ten-minute gap between the backup start and the restart is intentional. A panel “delay” is a wait time, not a completion check. A backup of a large world can take minutes to finish, so a restart scheduled sixty seconds after the backup begins can interrupt the archive. Two schedules ten minutes apart are easier to reason about than one schedule with a guessed delay.

Copying any of these schedules still requires a dialect check. A line containing 0 for Sunday is safe on Unix and Kubernetes but means something else in Quartz or AWS. A line containing a name alias is readable on Linux and unsupported on Vercel. The expression is portable only after the dialect is known.

Shorthand macros: @daily, @hourly, @weekly, @reboot — and where they don’t work

Some cron implementations support macros in place of the five fields. @yearly or @annually equals 0 0 1 1 *; @monthly equals 0 0 1 * *; @weekly equals 0 0 * * 0; @daily or @midnight equals 0 0 * * *; @hourly equals 0 * * * *. @reboot runs once when the daemon starts, which usually corresponds to a machine boot, and it has no five-field equivalent (Wikipedia).

Macros are convenient in a Linux crontab and unreliable in hosted schedulers. Kubernetes CronJobs work with five-field Vixie syntax and the @daily-style macros, but they do not support @reboot because a cluster has no single boot moment (JasperBernaers.com). GitHub Actions and AWS EventBridge do not support the macros in the same way. If portability matters, write the five fields out. They are longer by a few characters and they work in more places.

The Day-of-Month OR Day-of-Week Rule (The Most Expensive Misreading)

In standard Vixie cron, if both the day-of-month field and the day-of-week field are restricted — that is, neither contains * — the job runs when either field matches. The rule is OR, not AND. This is the most expensive misreading in cron expression syntax because it silently multiplies the number of runs.

The classic example is 0 0 13 * 5. Many people read it as “midnight on Friday the 13th.” In Vixie cron it means “midnight on every 13th, and also midnight on every Friday.” JasperBernaers.com estimates that produces about 60 runs a year rather than one or two. A monthly report written this way can start arriving weekly. A maintenance job written this way can run four or five times a month.

There is no way to express a true AND in standard five-field cron. The workaround is to leave one of the two day fields as * and test the exact condition inside the command. For example, schedule 0 0 13 * * and have the script check whether the day is Friday before proceeding. Some managed schedulers avoid the problem by disallowing both fields at once. Vercel’s documentation states that you cannot configure both day of the month and day of the week at the same time; when one has a value, the other must be * (Vercel). Quartz and AWS EventBridge require a ? in whichever day field is not being used, so only one day condition is ever active.

The self-check is simple: if both date fields are set to something other than *, stop and confirm that OR semantics are actually intended.

Schedules Five Fields Cannot Express: First Monday, Last Day, Friday the 13th

Some schedules look like cron problems but cannot be expressed in five fields. “The first Monday of the month,” “the last day of the month,” and “Friday the 13th” all require a cross-field condition. The first Monday needs a weekday plus a day-of-month range. The last day needs to know the length of the current month. Friday the 13th needs both day-of-month and day-of-week to be true at the same time, which standard cron cannot express because of the OR rule.

Quartz-style extensions add characters for some of these cases. L means last: in the day-of-month field it is the last day of the month, and after a weekday it is the last of that weekday. W means the nearest weekday to a given day, without crossing the month boundary. # followed by a number selects the nth weekday of the month. ? means “no specific value” and is used in one of the two day fields to keep the other active.

Availability is not universal. Quartz, AWS EventBridge, AWS Systems Manager, and Cloudflare support L, W, and # to varying degrees. Standard Linux cron does not. On Linux, the correct approach is to keep the five-field expression as a coarse filter and perform the exact date check inside the command. That also avoids the OR trap, because the expression no longer tries to encode a cross-field rule.

A common mistake on Linux is 0 9 1-7 * 1. It looks like “the first Monday of the month,” but because both day fields are restricted, Vixie cron reads it as “days 1 through 7, OR every Monday.” The job runs far more often than intended. The safer form is a daily or weekly coarse schedule plus a date test in the shell.

L, W, # and ? on Quartz, AWS and Cloudflare

Cloudflare Workers documentation supports five fields with Quartz-like extensions, including L and W in the day-of-month field and L and # in the weekday field (Cloudflare). Its examples include 0 18 * * 6L for 18:00 UTC on the last Friday of the month, and 59 23 LW * * for 23:59 UTC on the last weekday of the month. In Cloudflare’s weekday numbering, 1 is Sunday and 7 is Saturday.

AWS Systems Manager supports L, W, and # in its cron expressions, and its documentation gives cron(15 10 ? * 6L *) as 10:15 AM on the last Friday of every month and cron(0 2 L * ? *) as 02:00 AM on the last day of every month (AWS Systems Manager). The same documentation states that you cannot specify values in both the day-of-month and day-of-week fields; one of them must be ?. Quartz itself requires a ? in one of the two day fields, so only one day condition is active.

The Linux workaround: escaped `%` and a date test inside the command

On a standard Linux crontab, the workaround for “first Monday” or “last day” is to schedule a superset and filter inside the command. For a first Monday check, schedule the job every Monday at the desired hour and test whether the day of the month is 7 or earlier. For a last-day check, schedule it late in the month and test whether tomorrow is the first day of the next month. The shell expression must be written carefully because % has a special meaning in crontab files.

In a crontab command, an unescaped % turns into a newline, and everything after the first % is sent to the command as standard input. That is why date +%Y-%m-%d inside a crontab can behave incorrectly unless every percent sign is escaped as \%. The cleaner alternative is to put the logic in a script file and call the script from cron. The script runs under a normal shell, where % has no special meaning, and the crontab line stays short. If the command must stay inline, escape each % and test the expression with a parser or a manual run before trusting it.

Does Cron Use UTC or Local Time? Time Zones and DST

Cron schedules wall-clock time in the time zone of the host or service that runs it. The expression itself has no time-zone field. That means two servers with identical cron expressions can run the same job at different real-world moments if their system time zones differ. It also means a hosted scheduler that forces UTC will interpret 0 0 * * * as midnight UTC, which may be 19:00 or 20:00 in the user’s local time.

Several platforms force UTC. Vercel’s cron jobs always use UTC (Vercel). AWS EventBridge cron() rules are always UTC and offer no time-zone option. GitHub Actions scheduled workflows are always UTC. Kubernetes CronJobs default to UTC unless spec.timeZone is set, and that field only exists from Kubernetes 1.27 (JasperBernaers.com). Cloudflare Cron Triggers execute on UTC time (Cloudflare).

Daylight saving time adds two predictable failures. When clocks move forward, an hour disappears. A job scheduled inside that skipped hour does not run at all that day. When clocks move back, an hour repeats. A job scheduled inside that repeated hour runs twice, roughly an hour apart. In the United States, the affected local window is usually 01:00–03:00. A midnight reconciliation job may be safe from the skipped hour, but a job scheduled at 01:30 local can be skipped or duplicated depending on the direction of the clock change.

The skipped hour and the repeated hour

The spring-forward skip is silent. A job at 30 2 * * * simply has no matching wall-clock time on the transition day, so it does not run. No error is raised and no log line is guaranteed. The fall-back repeat is louder in its consequences. A billing run, an email send, or a counter increment that runs twice can produce duplicate charges or duplicate messages. The expression did not change; the clock did.

Mitigations: shift to 03:00, guard with a lock, or pin to UTC

Three practical mitigations reduce DST risk. The first is to move critical jobs outside the 01:00–03:00 local window, with 03:00 or later as a common target. The second is to make the job idempotent and guard it with a lock file so a repeated run does nothing harmful. The third is to schedule in UTC semantics and accept that a “9 AM” job drifts by an hour relative to local office hours twice a year. For machine-facing batch work, UTC is often the more predictable choice. For user-facing notifications, local time may still be worth the complexity, but the schedule should be reviewed against the DST calendar.

crontab -e: Where the Expression Actually Lives

The expression itself is only half of a working cron job. On Linux and Unix-like systems, the expression lives in a crontab file. User crontabs are edited with crontab -e and listed with crontab -l. System crontabs live in /etc/crontab or /etc/cron.d and are managed by system administrators. The behavioral history behind these files is long: cron dates to May 1975, Vixie cron was written in 1987, Vixie cron 4.1 was renamed ISC Cron in January 2004, Red Hat forked it to cronie in 2007, and anacron 2.3 was merged into cronie in 2009 (Wikipedia). Those names matter because “cron” behavior on a modern Linux distribution often comes from a Vixie-derived implementation plus later patches.

Cron’s environment is not the same as an interactive shell. The PATH is usually minimal, often /usr/bin:/bin, and shell profile files are not read. A command that works when typed into a terminal may fail with “command not found” under cron. Use absolute paths for binaries and scripts, or set a PATH= line at the top of the crontab. Output is another common silent failure point. Cron may try to mail stdout and stderr to the crontab owner, and if no mail system is configured, that output disappears. Redirect output explicitly with >> /var/log/job.log 2>&1.

To test the environment cron will use, run the command through env -i /bin/sh -c '...'. That reproduces the stripped environment and catches missing variables, relative paths, and profile-dependent assumptions. Plain cron also does not catch up on runs missed while the machine was off. If the machine was asleep or powered down when the scheduled minute passed, that run never happens. Anacron and systemd timers with Persistent=true exist to cover that gap, but they are not the same as standard cron.

System crontab’s extra user column

System crontabs add a user field before the command. A line in /etc/crontab or /etc/cron.d has six columns: five time-and-date fields, the user to run as, and the command. User crontabs do not have that column. Copying a five-field user crontab line into a system crontab shifts the command into the user field and can make the line fail or run as the wrong user. The reverse mistake is just as common: copying a six-column system line into crontab -e makes cron treat the username as the start of the command.

Before You Deploy: A Sanity-Check Checklist

A cron expression that parses is not necessarily a cron expression that does what you meant. Deployment checks should verify the next run time, the time zone, the overlap behavior, and the missed-run policy.

First, confirm the dialect and the forced time zone. A five-field expression in a six-field scheduler is either rejected or shifted. A UTC platform changes what “9 AM” means. Second, parse the expression and inspect the next several run times rather than only checking that the parser accepts it. Tools such as crontab guru and an online cron parser can show the next fire times, which is where field-order errors and */7 short gaps become visible. Third, check both day fields. If day-of-month and day-of-week are both restricted, confirm that OR behavior is intended. Fourth, decide whether the job can overlap and protect it if it can.

Verify per platform: runnable commands

Different platforms have different verification paths.

Linux crontab: test the command environment with env -i /bin/sh -c '/path/to/job.sh'. This catches missing PATH entries and profile dependencies.
systemd timer: run systemd-analyze calendar 'OnCalendar=...' to print the next elapse time before enabling the timer.
Kubernetes CronJob: run kubectl create job --from=cronjob/<name> manual-run-1 to start the job immediately without waiting for the schedule.
Cloudflare Workers: use wrangler dev and call the local scheduled route at /cdn-cgi/local/scheduled to test the handler. The documentation shows curl "http://localhost:8787/cdn-cgi/local/scheduled" and supports a ?cron= parameter to simulate a pattern (Cloudflare).
Parser check: crontab guru or cron-parser can translate the expression and list upcoming runs. Verify the next run time, not just whether the expression parses.

Stop overlapping runs and spread load: flock, Jenkins H, RandomizedDelaySec

If a job can take longer than its interval, prevent overlapping runs. On Linux, wrap the command in flock -n /tmp/job.lock, which exits immediately if the lock is already held. On Kubernetes, set concurrencyPolicy: Forbid on the CronJob so a new run does not start while the previous one is still active. In application code, an advisory lock or a lock file can do the same job.

High-frequency schedules also create load spikes when many jobs fire at the same minute. Jenkins uses H to substitute a hashed value, so each job runs at an unspecified but invariant time within the hour instead of all jobs starting at minute 0 (Wikipedia). systemd timers use RandomizedDelaySec to jitter starts across a fleet. Both approaches spread load without changing the underlying cadence. For missed runs, remember that cron does not catch up. Anacron and systemd timers with Persistent=true do, but their catch-up timing differs, so the behavior should be documented alongside the schedule.

Two final checklist items belong at the top: confirm whether the platform is local time or UTC, and confirm whether both date fields are restricted. Those two checks prevent a large share of “the job ran at the wrong time” and “the job ran too often” incidents.

Kubernetes CronJobs and GitHub Actions: Same Syntax, Different Rules?

Kubernetes CronJobs and GitHub Actions scheduled workflows both accept five-field Vixie-style cron expressions, but the syntax is where the similarity ends. The differences are operational guarantees, not field definitions.

Kubernetes CronJob syntax matches crontab for the five fields and supports the @daily-style macros, but it does not support @reboot because a cluster has no single boot moment. The default time zone is UTC unless spec.timeZone is set. concurrencyPolicy controls whether a new run can start while the previous one is still active; Forbid prevents overlap. startingDeadlineSeconds controls how late a missed run may still start. If a CronJob misses too many schedules, the controller can give up on it, and the reason is recorded as an event. Those are runtime behaviors layered on top of the expression.

GitHub Actions scheduled workflows are best effort. They can be delayed by 5 to 30 minutes, especially at busy times such as the top of the hour. They run in UTC only. Intervals shorter than five minutes are not honored. A scheduled workflow is also disabled automatically after 60 days without repository activity (JasperBernaers.com). A correct expression therefore does not guarantee an on-time run. For jobs that must happen on time, trigger them from a system that guarantees delivery and use Actions as the runner rather than the scheduler.

Kubernetes CronJob: UTC default, concurrencyPolicy, startingDeadlineSeconds

The Kubernetes CronJob spec accepts the standard five fields. The default schedule interpretation is UTC, and spec.timeZone is only available from Kubernetes 1.27. concurrencyPolicy: Forbid is the built-in way to stop overlapping runs, which is often preferable to a lock file inside the container. startingDeadlineSeconds defines the window after the scheduled time in which a missed run may still start. If the controller misses too many schedules in a row, it stops creating jobs and records an event. The expression can be perfectly correct while the runtime still skips or delays a run.

GitHub Actions: best-effort timing, UTC only, disabled after 60 days

GitHub Actions scheduled workflows use five-field cron syntax, but they are explicitly best effort. Delays of 5 to 30 minutes are normal, and runs can be dropped at peak times. Schedules shorter than five minutes are not honored. The time zone is always UTC. Scheduled workflows are disabled after 60 days without repository activity, so a dormant repository can silently stop running its schedule. These are platform policies, not syntax errors.

Managed Schedulers Beyond Linux: Vercel, AWS, and systemd Timers

When moving from a Linux crontab to a managed scheduler, check three things before copying the expression: whether name aliases are supported, whether both day fields can be set, and whether the time zone is forced. Those three checks catch most migration failures.

Vercel uses five fields but does not support MON, SUN, JAN, or DEC. It does not allow both day-of-month and day-of-week to be configured; one must be *. It always uses UTC. Each invocation includes an x-vercel-cron-schedule header containing the cron expression that triggered it, which helps distinguish schedules when multiple cron jobs share the same path (Vercel).

AWS EventBridge uses six fields with a year field last, requires ? in one of the two day fields, treats Sunday as 1, and always uses UTC. AWS Systems Manager has two different cron modes. Maintenance windows require six fields and support the fastest rate of five minutes. Associations require five fields and must use an interval of at least 30 minutes; AWS states that associations cannot use cron or rate expressions shorter than that. Maintenance windows support L, W, and #, while associations also support # and L in their documentation examples (AWS Systems Manager).

systemd timers are the server-side alternative to cron. They use OnCalendar, support Persistent=true for catch-up, and support RandomizedDelaySec for jitter. systemd-analyze calendar verifies the schedule before the timer is enabled. The trade-off is real: a managed platform may give stronger delivery guarantees but removes some syntax freedom, while a server crontab keeps more syntax freedom but leaves overlap protection and catch-up behavior to the operator.

Vercel Cron Jobs: no name aliases, one day field, always UTC

Vercel supports five fields with minute, hour, day of month, month, and day of week. It does not support name aliases. It does not allow both day-of-month and day-of-week to be restricted. It always uses UTC. The invocation header x-vercel-cron-schedule tells the function which expression triggered it. Those constraints make Vercel simpler in one way — the OR trap cannot occur — and stricter in another: an expression copied from a Linux crontab that uses MON or JAN will not work.

AWS EventBridge and Systems Manager: six fields, `?`, Sunday = 1

AWS EventBridge cron() expressions use six fields with a year at the end, require ? in exactly one of the day fields, and use Sunday as 1. They are always UTC. AWS Systems Manager maintenance windows require six fields and support a minimum rate of five minutes. Systems Manager associations require five fields and support a minimum interval of 30 minutes, and they do not currently support specifying months. Both AWS paths support advanced day syntax to different degrees, so the correct reference is the specific AWS service documentation, not a general cron guide.

systemd timers: OnCalendar, Persistent, RandomizedDelaySec

systemd timers use a different calendar syntax, not cron syntax. OnCalendar defines the schedule, Persistent=true runs a missed job after the machine comes back, and RandomizedDelaySec adds jitter so a fleet does not start every job at the same second. systemd-analyze calendar prints the next elapse time and is the verification step before enabling the timer. One semantic difference matters when migrating: cron treats day-of-month and day-of-week as an OR when both are restricted, while systemd treats them as an AND. A schedule that uses both fields can fire on fewer days as a timer than it did as a crontab line.

Conclusion

Cron expression syntax comes down to five fields and four operators, but the errors that cost real time usually come from outside the grammar. Sunday numbering changes between dialects, the day-of-month and day-of-week fields combine with OR semantics in Vixie cron, and time zones and daylight saving can skip or repeat a run without any syntax mistake. Before writing the first expression, identify the scheduler and the forced time zone. Before deploying, use a cron parser or a platform-specific command to verify the next run time, then protect the job with a lock or concurrency policy if it can overlap. The expression is only one part of a reliable schedule.

FAQ

Is Sunday 0 or 7 in a cron expression?

Unix, Kubernetes, Jenkins, GitHub Actions, and Spring accept 0 for Sunday, and most also accept 7. Quartz, AWS EventBridge, and Cloudflare use 1 for Sunday, where 0 is either invalid or means something different. The safe approach is to confirm the dialect before using a number, or use a name alias such as SUN when the platform supports it. Vercel does not support name aliases, so its numeric range must be checked directly.

Does cron use UTC or the local time zone?

The expression itself carries no time zone. Cron matches the wall-clock time of the host or service running it. Vercel, AWS EventBridge, GitHub Actions, and Kubernetes CronJobs default to UTC. A Linux crontab uses the server’s local time unless a TZ= line overrides it. If the job matters, confirm the time zone before converting local intentions into an expression, or deliberately schedule in UTC and accept the seasonal drift.

Why does my cron job run more often than I expected?

The most common cause is the day-of-month and day-of-week OR rule. When both fields are restricted, Vixie cron runs the job when either matches, so 0 0 13 * 5 fires on every 13th and every Friday. The second common cause is a step that does not divide its range, such as */7 in the minute field, which creates a short gap at the end of each hour. Also check for duplicate crontab entries or repeated deployments.

Can cron run a job every 30 seconds?

Standard five-field cron cannot. Its smallest unit is one minute, and there is no seconds field. Schedulers that support seconds use a six-field format with seconds first, including Quartz, Spring, and Azure NCRONTAB. On a plain Linux server, the usual workaround is a one-minute job that loops internally with sleep, or a systemd timer with OnUnitActiveSec. GitHub Actions does not honor intervals shorter than five minutes.

What does `/5 * * *` mean, and what does `5` mean instead?

*/5 in the minute field selects minutes 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, and 55 — twelve runs per hour. A plain 5 selects only minute 5 of each hour — one run per hour. The difference is that */n steps through the allowed values rather than measuring an interval, so a step that does not divide 60 evenly produces an inconsistent final gap.

How do I schedule “the first Monday of the month” or “the last day of the month”?

Five-field cron cannot express those cross-field conditions directly. Quartz, AWS, and Cloudflare support # for the nth weekday and L for the last day. On Linux, schedule a coarse run and test the date inside the command, escaping % as \% if the crontab line uses date formatting. Avoid 0 9 1-7 * 1 on Vixie cron, because the OR rule makes it run on days 1–7 and every Monday, not only the first Monday.

2026年10月13日

Rep Counter: How Automatic Counting Works (2026 Guide)

A rep counter automatically tracks your repetitions during a set. In 2026, the leading options are camera-based iPhone apps such as RepCount and Push Up Counter. They follow your body on-device, count only full reps, and need no wearable or sensor.

If you actually searched for “Rep.” seat counts, the CSS counter-reset property, or a WoW reputation boost, jump to the disambiguation section below—this guide points each of those intents to where it belongs.

What Is a Rep Counter—and What Is It Actually Counting?

In a fitness context, a rep counter is a tool that automatically records how many repetitions you complete in a set. In 2026, the mainstream form factor is a phone app that uses the device camera rather than a wearable, a sensor, or a smart mat. Push Up Counter describes its own product the same way: it “turns your iPhone into a hands-free rep counter,” with “no wearables, no tapping between reps.”

The core question a rep counter answers is narrow and specific: how many did I just do? That matters because counting in your head drifts, and a partner counting out loud is not available to most people training at home. Moving the count to software returns attention to the set itself—pace, depth, and whether your hips held position.

Three things define the category as it stands today:

A primary movement is counted. Camera apps in the current market are built around one flagship exercise, most often the push-up.
Counting is automatic. The app advances the number when it sees a completed repetition, not when you tap.
Form is part of the count. A repetition that does not meet a depth or alignment threshold is typically rejected rather than added to the total.

“Rep Counter” vs. Three Other Meanings of “Rep”

The phrase “rep counter” competes with at least three unrelated intents, and it is worth routing them explicitly.

Politics. In political coverage, “Rep.” is the abbreviation for Representative, a member of the U.S. House. A “rep counter” in that context is a tally of House seats. According to the House Press Gallery, the 119th Congress stands at 218 Republicans, 214 Democrats, one Independent, and two vacancies—the vacancies following the resignations of Rep. Tony Gonzales (R-TX) on April 14, 2026 and Rep. Sheila Cherfilus-McCormick (D-FL) on April 21, 2026.

CSS. The counter-reset property creates and initializes named CSS counters; it has been baseline-available across browsers since July 2015, per MDN Web Docs. Counterintuitively, it is counter-set, not counter-reset, that resets the value of an existing counter.

Gaming. A “rep boost” in World of Warcraft refers to paid reputation farming. One vendor, Gamingcy, sells a Consortium reputation boost from $19 with a stated ETA of 7–21 days.

This guide covers only the fitness meaning.

How Does Automatic Rep Counting Actually Work? Camera, Sensor, and Manual Compared

Automatic rep counting is not one technology. There are three distinct paths, and the differences between them explain almost everything about which one works where.

Camera-Based Pose Tracking: Landmarks, Joint Angles, and a State Machine

The camera path has three stages. First, a pose model finds body landmarks in each video frame. Second, the system computes joint angles from those landmarks. Third, a state machine decides when a repetition has started and finished.

The landmark models are the same ones used across mobile computer vision. RepCount uses the iPhone’s front camera together with Apple Vision to detect body movement in real time—its product description states it “automatically counts your exercise reps so you can focus on your workout—not the numbers,” with no manual input required.

An open-source project, PushForm, documents the same pipeline in more detail in a GitHub specification. It runs a MediaPipe Tasks Vision pose landmarker on-device—the lite model, with a GPU delegate and CPU fallback, targeting 30 frames per second—and streams 33 landmarks per frame to a backend that computes angles in 2D. Elbow angle is computed for both sides each frame, median-filtered over five frames, and passed through a hysteresis state machine: the phase enters DOWN below 95 degrees and leaves DOWN above 155 degrees, with no transition inside that band. A rep is the interval from entering DOWN to leaving DOWN.

Sensor and IMU Counting: Why It Works on Barbells and Fails on Cables

The sensor path relies on an inertial measurement unit. Acceleration data is integrated to estimate a driving impulse, and thresholds decide when a repetition has occurred. This works on barbells because barbell travel is geometrically predictable.

The failure mode is documented. A BarSpeed issue reports that the impulse counter’s thresholds were “fitted at travelRatio 1.0 and are not converted through the pulley ratio, so on a stack they are applied in the wrong frame.” The measured collapse on paced machine captures was stark: a leg curl set of 10 reps produced 2 calls, a leg curl set of 12 produced 0, a single-leg press set of 8 produced 0, and a pull-up set of 8 produced 0.

Worth noting: the same issue reports that the alternative detector was measured at 108 calls against 253 over the same corpus—so narrowing the gate is not a free win either.

Manual Counting: Still the Only 100% Reliable Option (and Why That’s Fine)

Manual counting remains the correct choice in two situations: movements the camera cannot see clearly, and test sets where you need absolute certainty. A one-tap online rep counter does that job without any camera at all. It is not a failure of the technology. It is the honest answer when the sensor geometry does not match the exercise.

What Counts as a Full Rep? Depth, Lockout, and the Partial Rep Problem

Every automatic counter has to make a judgment call: is this a complete repetition, or is it a half-range wobble? The rules that decide this are where products differ most, and where a counter’s number either means something or does not.

Hard Rules First, Classifier Second: A Layered Form Gate

One public example shows how a layered gate can be built. In the PushForm specification, deterministic hard rules are evaluated at the end of each rep, in a fixed order of precedence:

Rule	Threshold	Fault label
Hip sag	mean signed hip deviation below −20°	hip sag
Hip pike	mean signed hip deviation above +20°	hip pike
Partial range of motion	minimum elbow angle exceeds 110°	partial ROM

Alongside these, the specification defines timing behavior: a DOWN phase shorter than 400 ms is a Bounce—the phase still changes, but no rep event is emitted. If the smoothed elbow angle stays inside the hysteresis band for more than 1.5 seconds, a stall event fires once and clears when the angle leaves the band. Tracking loss is declared when the tracked side’s elbow landmarks fall below 0.6 visibility for more than five consecutive frames; the machine freezes in its current phase, and the rep resumes when tracking returns.

If no hard rule fires, a trained classifier evaluates the rep’s feature vector—but a fault label is applied only when the predicted probability is at least 0.7. Below that confidence floor, the rep counts. These thresholds come from an individual open-source project, not an industry standard, and are useful as a reference point rather than a prescription.

The commercial version of the same philosophy is simpler to state. Push Up Counter says a rep “has to reach depth,” that anything shallower “is recorded as a partial rather than counted,” and that partials “form the denominator of your form score—so the number you finish with is the number you actually earned.”

Why You Can’t Judge Depth From a Front-Facing 2D Pose

A front-facing camera cannot reliably determine how far you lowered your chest—there simply is not enough depth information in a 2D pose from that angle. Push Up Counter addresses this directly: the side view is the position that checks depth, and from a front-facing 2D pose the app “counts reps but leaves the depth verdict to a side view.” If you want depth gating, camera placement is not optional.

Which Exercises Can a Rep Counter Handle—and Which Ones Break It?

This is the question the current market does not answer well. Product pages rarely state which exercises a counter handles and which ones it quietly fails on. The following decision table consolidates what the available evidence supports.

Exercise × Equipment Decision Table

Exercise / equipment	Recommended counting	Known failure risk	Basis
Push-up (bodyweight)	Camera	Needs a side view for depth; knee push-ups out of scope in PushForm v1	Push Up Counter, PushForm spec
Barbell squat / bench / deadlift	Sensor or IMU	Thresholds fitted to barbell travel; tempo’d sets may not be counted at all	BarSpeed #303
Pull-up (bodyweight + bar)	Unreliable—verify before trusting	8 performed reps produced 0 calls in measured data	BarSpeed #303
Leg curl (machine)	Manual	2/10 and 0/12 correctly detected	BarSpeed #303
Single-leg press (machine)	Manual	0/8 correctly detected	BarSpeed #303
Cable row, face pull, Pallof press	Manual	No rep marks exist in the public corpus to score them	BarSpeed #303

Why Cable and Machine Sets Are the Hardest Case

Cables and machines break automatic counting for a structural reason, not a tuning reason. An impulse counter’s thresholds are numbers in a drive frame fitted at a travel ratio of 1.0—the geometry of a barbell moving freely. On a stack, the cable and pulley ratio changes the relationship between how far the handle moves and how far the load moves. Apply barbell-frame thresholds to a stack and they land in the wrong frame.

The pull-up result is the most instructive row in the table. It is a bodyweight movement on a bar, which sounds like an easy case, yet 8 performed reps produced 0 detected calls in the measured set. “Bodyweight plus bar” does not automatically mean a camera counter will handle it either—visibility, occlusion, and the movement path all matter.

The practical conclusion is unglamorous: for cable and machine work, keep logging manually — a manual rep counter is still the reliable tool — until the technology catches up.

Does a Rep Counter Record or Upload Your Workout Video?

For camera-based apps, the privacy dividing line is simple to state: does the video ever leave the device?

The leading products in this category say no. Push Up Counter states that all processing happens on device, that no video is ever recorded or uploaded, that there are no accounts and no ads, and that counting runs offline. RepCount similarly performs detection on-device using the front camera and Apple Vision.

This is a structural advantage of the camera path rather than a marketing choice. Pose inference is light enough to run locally, so there is no technical reason to upload frames to a server for the core counting function. A cloud-dependent design would introduce both latency and a privacy surface that the on-device approach avoids.

Before installing any rep counter app, ask four questions:

Is video ever stored on the device?
Is any video or landmark data uploaded?
Is an account required?
Does counting still work with the network off?

A camera-based counter that answers “no, no, no, yes” is behaving the way the category’s leading products do.

Sets and Reps: How a Rep Counter Fits Into Your Training Log

The terminology matters because automatic counting has to understand all three terms to be useful.

Set — a continuous block of repetitions performed without rest.
Rep — one complete repetition within that block.
Rest — the interval between sets.

A counter that only knows reps produces a number with no structure. A counter that understands sets can close a set when you stop to rest and open a new one when you start again. Push Up Counter describes exactly this behavior: “Stop to rest and the app closes the set. Start again and it opens a new one—no buttons in the middle of a workout.” The PushForm specification uses the same vocabulary in a defined glossary, distinguishing a Set, a Connection, and a Rep as separate concepts.

Why does set structure matter beyond convenience? Training volume is calculated as sets × reps × load. If set boundaries are wrong, volume is wrong, and every downstream metric built on volume inherits the error. Getting sets and reps correctly segmented is the precondition for any strength-tracking logic layered on top—including estimated one-rep max.

Rep Counter Apps Compared: RepCount, Push Up Counter, and PushForm

Three products illustrate the range of approaches available in 2026.

RepCount is an iOS app that uses the iPhone’s front camera and Apple Vision to detect body movement in real time and count reps automatically, with no manual input. Its framing is about attention: count the reps so you can focus on the workout, not the numbers. Source: App Store listing.

Push Up Counter: Muscles is an iPhone and iPad app built specifically around the push-up. It offers three phone placements—facing you, beside you for a side view, or flat on the floor below your face—counts only reps that reach depth, records shallower attempts as partials that form a form score denominator, groups sets automatically, shows live pace in reps per minute, and includes a six-week program that opens with one max-effort set to set your level. Pricing is a free download with a 7-day trial, after which either a monthly subscription or a one-time lifetime unlock applies. Source: pushupcounter.app.

PushForm is an open-source Python web app documented in a public specification. Version 1 supports standard push-ups only; knee push-ups and any exercise-mode selector are explicitly out of scope, as are front-on or overhead orientations and multi-person tracking. Its value here is transparency: the full decision logic, thresholds, and acceptance criteria are readable. Source: GitHub issue #1.

Pricing models differ meaningfully. Free trial plus subscription suits users who want a maintained product without a large upfront cost. A one-time lifetime unlock suits users who dislike recurring charges. Fully open source suits developers who will self-host. Note that PushForm and BarSpeed are individual GitHub projects—they are not industry standards, and their specifications should be read as documented engineering decisions rather than consensus rules.

How to Choose: Four Questions That Decide It for You

Which exercise do you actually train most? If it is the push-up, a purpose-built counter will be more accurate than a general one.
Can you place your phone for a side view? Depth gating depends on it, so if your training space does not allow it, expect counting without depth judgment.
Does the app promise on-device processing? Confirm this in the privacy policy before installing.
Which pricing model fits how you train? A subscription is only worth it if you will still be using the app in six months.

Turning Rep Counts Into Progress: e1RM and RPE Baselines

Most of the search results in this space split into two camps: rep counting apps that never mention estimated one-rep max, and 1RM calculators that never mention rep quality. That split is a mistake, because rep quality directly determines how much you should trust an e1RM.

An e1RM is a prediction of the most weight you could lift for a single repetition, based on a submaximal set. Barbell Medicine’s 1RM calculator incorporates RPE into the estimate and notes that “lower-repetition sets, especially sets of 1 to 5 reps performed at higher RPEs, tend to produce more useful 1RM estimates.” The calculator also cautions that e1RM is a ballpark figure, not a prescription: fatigue, technique, range of motion, and day-to-day performance all affect the relationship between a training set and a true 1RM.

The dependency is direct. A set of 5 reps at RPE 9 only estimates your maximum usefully if those 5 reps were full-range. Five partial reps at the same RPE would overstate or understate your capacity depending on how the depth shortfall was scored. This is where rep counting and 1RM estimation connect: accurate counting is the input, e1RM is the output.

For context on what strong looks like, a 2024 analysis of more than 800,000 raw, drug-tested powerlifting competition results reported the following averages, as summarized by Barbell Medicine:

Lift	Men	Women
Squat	2.17× bodyweight	1.64× bodyweight
Bench press	1.5× bodyweight	0.95× bodyweight
Deadlift	2.51× bodyweight	1.98× bodyweight

For health rather than performance, a dataset of nearly 9,000 men aged 20 to 82 found that a leg press 1RM of 1.9× bodyweight and a bench press 1RM of 1.1× bodyweight were associated with the lowest risk of mortality (underlying study indexed at PubMed 18595904). No equivalent dataset exists for women, but extrapolating from data showing women average roughly 50% of male upper-body strength and 60% of lower-body strength yields targets of about 0.55× bodyweight on bench press and 1.14× on leg press.

The operating order is: get counting accurate and depth-compliant first, then use your cleanest qualifying sets to estimate e1RM, then track e1RM over time.

How to Build Your Own Rep Counter (Developer Path)

For developers, the search results in this space offer scattered GitHub issues and no consolidated path. The following six-step sequence reflects the pipeline documented in the PushForm specification.

Extract pose landmarks. Run a pose landmarker on-device—in this example, MediaPipe Tasks Vision’s lite model with a GPU delegate and CPU fallback, targeting 30 fps and streaming 33 landmarks per frame.
Compute joint angles. Calculate elbow angle for both sides every frame. Select the tracked side as the one with higher mean landmark visibility over the last 10 frames, and re-evaluate that choice only while in the UP phase.
Build a hysteresis state machine. Enter DOWN below 95 degrees, leave DOWN above 155 degrees, and do not transition inside the band. Defaults should be overridable between sets, never during one.
Apply hard rules. Evaluate deterministic faults in a fixed order—hip sag, hip pike, then partial range of motion—so the system produces form feedback even with no model loaded.
Add a grey-zone classifier. When no hard rule fires, classify the rep’s feature vector and apply a fault only at or above a confidence floor. The documented floor is 0.7: a stub classifier at 0.69 probability counts, at 0.70 it rejects.
Deploy on-device. Normalize rep features by torso length so they do not drift with camera distance, and hold the last good angle for five frames when landmark visibility drops before declaring tracking lost.

For measurable acceptance criteria, the same specification targets a macro-F1 of at least 0.85 on stratified cross-validation and at least 0.75 on a held-out collection day, over a dataset of roughly 40 reps per class collected across at least three sessions, two lighting conditions, and both facing directions.

These thresholds come from one individual open-source project. They are a concrete starting point, not a standard you are obliged to meet.

Conclusion

A rep counter in 2026 is genuinely useful—camera-based, on-device, and accurate on full reps—but its value depends entirely on knowing what it can and cannot see. Pick one camera-based app, set your phone at a side angle so depth can actually be judged, and accept that only full reps count toward your total while partials feed your form score instead. Then use your cleanest low-rep, high-RPE sets to estimate e1RM and track real strength progress. For cable and machine work, keep logging manually until the technology catches up.

FAQ

Do I need a wearable or smart mat to use a rep counter?

No. In 2026 the leading rep counters are camera-based phone apps—RepCount and Push Up Counter both work with just your phone’s camera. No wearable, sensor, or smart mat is required. The trade-off is that you need a clear camera angle and enough space in frame.

Does a rep counter count partial reps, and what happens to them?

Most quality apps deliberately do not count partial reps toward your total. Push Up Counter, for example, records anything shallower than its depth threshold as a “partial” rather than a completed rep. Those partials still show up—they form the denominator of a form score—so you can see how many attempts fell short.

Is my workout video recorded or uploaded to a server?

With the leading camera-based apps, no. Processing happens entirely on-device: no video is recorded, nothing is uploaded, no account is required, and the app works offline. Always verify this in the app’s privacy policy before installing, but on-device pose inference is now the norm for this product category.

Can a rep counter track cable, machine or leg-press sets?

Not reliably today. Sensor-based counters tuned to barbell geometry have measured near-total failure on cables and machines—one public dataset showed 2/10, 0/12, 0/8, and 0/8 reps correctly detected across four machine sets. Camera-based counting needs a clear side view and may struggle when the body moves with the cable path. For now, manual logging — or a simple online rep counter — remains the safe choice for machine work.

Is a rep counter app free, or do I need a subscription?

It varies. Push Up Counter offers a free download with a 7-day trial, then either a monthly subscription or a one-time lifetime unlock. Open-source projects like PushForm are free but require self-hosting and currently support only standard push-ups. No single pricing model dominates the category yet.

What does “rep counter” mean when it refers to Congress?

In political coverage, “Rep.” is short for Representative—a member of the U.S. House. A “Rep counter” in that context means a tally of House seats. As of the 119th Congress, the House stands at 218 Republicans, 214 Democrats, one Independent, and two vacancies (source: House Press Gallery). This is unrelated to fitness rep counting.

2026年10月9日

Luau Formatter: What It Changes and How to Use It

A Luau formatter rewrites Luau source into a consistent layout—spacing around operators, braces, keywords, and type annotations—without changing what the code does. As of October 2026, the Sparkdown formatter runs on save in its VS Code extension and web editor, and it must return identical output when run again.

What a Luau Formatter Actually Changes (and What It Never Touches)

A Luau formatter only rewrites the layout layer of a file: the space around operators, the space inside braces, line breaks and indentation after keywords, and spacing inside type annotations. The program’s behavior stays the same.

That boundary comes from the parser. A formatter edits whitespace that has already been classified into grammar nodes. It does not rename identifiers, reorder expressions, or rewrite the contents of strings. If a formatting diff changes anything other than whitespace, that is an implementation defect, not a feature.

In this ecosystem, the formatter is Sparkdown‘s document formatter, exposed as getDocumentFormattingEdits under packages/sparkdown-language-server/src/utils/providers/. The VS Code extension and the web editor share that one provider, so both surfaces produce the same output. Only the trigger—a save event versus Mod-S—and the surrounding UI differ.

Every rule follows a simple model: whitespace falls into two categories. Whitespace the parser judges to be extra is deleted. Whitespace judged to be an optional separator is normalized to exactly one space. In the ImpowerGames/impower tracker, most formatting bugs trace back to a single grammar rule putting a token in the wrong category.

The practical test for this class of formatter is the diff itself: it should show whitespace changes only. If tokens move, either you are running a different tool or the build is broken.

The two whitespace categories behind every Luau formatting rule

The difference between ExtraWhitespace and OptionalWhitespace explains behavior that otherwise looks arbitrary. ExtraWhitespace collapses to nothing. OptionalWhitespace acts as a separator: if it is empty, one space is inserted; if it contains several spaces, it shrinks to one.

Issue #1108 shows both categories hitting the same source position. In {[k] = v}, the space after ] is the first capture of LuauAssignmentOperation‘s begin, and that capture is classified ExtraWhitespace, so the formatter deletes it. In the rewritten {[k]= v}, that same capture is empty, and the leading capture of LuauAssignmentOperator becomes a zero-width OptionalWhitespace between ] and =, which the formatter widens to one space. The two classifications take turns undoing each other.

FormattingAnnotator: marking the whitespace a formatter is allowed to edit

FormattingAnnotator, in packages/sparkdown/src/compiler/classes/annotators/, labels whitespace nodes so the formatter knows what it may touch. A mid-line OptionalWhitespace is marked as a separator, which normalizes it to one space and inserts one when it is empty.

The annotator also keeps the explicit exceptions. It forces a trailing space for the keywords listed in KEYWORDS_REQUIRING_TRAILING_SPACE and for the concat operator ... That keeps the forced-space rules in one table instead of scattering them across the formatter. When a keyword or operator is missing from that table, the generic character-level rule wins and the space disappears—the source of several bugs below.

How to Run a Luau Formatter on Save in VS Code and the Web Editor

Getting format-on-save working correctly takes three steps, and the order matters. The third step is the one that protects your code.

Open a .luau file in VS Code with the Sparkdown extension installed, or open your project in the web editor. The extension and the web editor are both labeled surfaces on the same Sparkdown provider, so the rules are identical in either place.
Point the language’s default formatter at Sparkdown’s document formatter, then enable editor.formatOnSave. If you prefer not to auto-save, Mod-S in the web editor triggers the same formatting path manually. That is the recommended way to start.
Format once manually and read the diff before you enable automatic saving. Confirm the change is whitespace-only. If you turn on format-on-save first, the very first run can touch valid code before you have verified what the build does.

Steps 1 and 2 are easy. Step 3 exists because editor-side behavior is treated as a separate verification item in this project, not as a given. Issue #1226 and issue #1227 both list editor verification in their acceptance criteria: a screenshot of Mod-S in the web editor before and after, and format-on-save checked in a desktop development host or explicitly disclosed as unchecked. The rule layer can be validated in Node while the editor path has not been driven at all. Several issues state plainly, “Reproduced in Node; not checked in either editor.”

What a safe Luau formatting diff should look like

A safe diff only adds or removes spaces and blank-line whitespace—nothing else. The specific shapes to expect are the ones the tracker pins: a space added inside a one-line table’s braces, a trailing space restored after return, or several spaces reduced to one around an operator.

If you see a keyword merged into a following brace (return{1}), a type’s spacing changed (Array <number >), or a bracketed key whose = spacing flips on the next save, stop. Treat it as an implementation problem. Do not edit your source to match the output.

Confirming you are running the Sparkdown document formatter

Several extensions can register a formatter for the same language, so when output looks wrong, check which provider actually ran. Set Luau’s default formatter explicitly to Sparkdown’s document formatter instead of picking from a list each time. That way, formatOnSave cannot silently route to a different tool.

The second check is the surface. The language server’s document formatter is the shared one. If format-on-save produces a result that the same file does not produce when formatted manually through that provider, the problem is in the editor integration path, not in the spacing rules.

Luau Formatter Spacing Rules: The Before-and-After Reference

These rules are scattered across the acceptance criteria of individual issues. Gathered into one table, each row gives a string you can paste in, the output a correct formatter should produce, and the issue that pins it.

Input as typed	Expected output	Rule	Source
`{hp = 8, items = {"potion", "apple"}}`	`{ hp = 8, items = { "potion", "apple" } }`	One space after `{` and one before `}` in a one-line table	#1226
`{k = v}`, `{ 1, 2 }`, `{ [k] = v }`, `{ x: number }`, `{ number }`	`{ k = v }`, `{ 1, 2 }`, `{ [k] = v }`, `{ x: number }`, `{ number }`	Same rule for table constructors and table types	#1226
`{}` / `{ }`	`{}` / `{}`	An empty table stays tight	#1226
`{{1}, {2}}`	`{ { 1 }, { 2 } }`	Nested one-line tables	#1226
`"HP: {hp}"`, a backtick string’s `{x}`, `#value={volume}`	unchanged	Interpolation and binding braces are not tables and stay tight	#1226
A multi-line table	unchanged	Contents keep their own lines and indentation; trailing-comma rule unchanged	#1226
`return { 1 }`, `in { 1, 2 }`	space kept	A keyword before a table keeps its space	#1226
`f{ 1 }`, `a[1]`, `f(x)`	tight	A call keeps no space	#1226
`Array<number>`, `Map<string, number>`	unchanged	Generics stay tight against the type name	#1095
`number?`, `local u: number? = 1`	unchanged	Optional `?` glued to the type; `=` keeps one space each side	#1065
`local x = y :: number`	unchanged	`::` keeps one space on each side	#1099
`local x: number`, `obj:method()`	unchanged	The annotation and method-call colon stays tight	#1099
`s ..= "b"`	unchanged	`..=` keeps its leading space	#1114
`x += 1`, `x -= 1`	unchanged	The other compound assignments keep their space	#1114
`local s = 'x' .. 'y'`	`local s = "x" .. "y"`	Single-quoted strings normalize to double quotes; the operator space survives	#1097

One-line Luau tables and table types: inner brace spacing

Tables should end up as { hp = 8, items = { "potion", "apple" } }: one space after the opening brace and one before the closing brace. This applies to one-line table constructors (nodes LuauTable, LuauTypeTableStruct) and one-line table types. { a = 1 }, { 1, 2 }, { [k] = v }, { x: number }, and { number } all follow the same rule. A nested table such as {{1}, {2}} becomes { { 1 }, { 2 } }.

The rule has to be implemented by node rather than by character because { and } are the same characters used in interpolation braces. The formatter historically decided spacing by character, with { in NO_SPACE_AFTER and } in NO_SPACE_BEFORE at getDocumentFormattingEdits.ts:23. That is why { a = 1 } collapsed to {a = 1}, and why a define table and an animation block on neighboring lines could be spaced differently.

Tight suffixes: generics, optional `?`, and interpolation braces

Three suffixes stay glued to what comes before them: generic angle brackets, the optional type ?, and interpolation or binding braces.

For generics, the expected output is unchanged input. Array<number> and Map<string, number> keep no space before < or before >. At bfb1197a6, the formatter instead produced Array <number > and Map <string, number >. The cause: LuauTypeName and LuauPrimitiveType end with a trailing _LUAU_BINARY_OPERATOR_AHEAD_ whose lookahead includes the comparison operators <=? and >=?. As a result, the < and > of a generic looked like a comparison that could follow a value. The output was stable on a second pass, so a formatted script kept the misspelled type.

The same mechanism produced number ? for the optional suffix. When a value followed (local u: number? = 1), the space before = was also removed, yielding local u: number ?= 1—a line that reads like a ?= operator (issue #1065, reported at c51ea0bfa). A type without the suffix, such as local s: string, was left alone.

Operators that keep their spaces: `::` and `..=`

Two operators are easy to get wrong because the character-level rule looks past the operator.

The cast operator :: should keep one space on each side, the same as y + 1 or a .. b. At bfb1197a6, the formatter emitted local x = y:: number. The space before :: is an OptionalWhitespace passed to shouldInsertSpaceBetween; the next character is the first : of ::, and : sits in NO_SPACE_BEFORE, so the separator collapsed. The space after :: is a separate node and survived, giving an asymmetric result (issue #1099). The tight colon in local x: number and obj:method() must stay tight under the same fix.

The ..= compound assignment should keep one space before it, as += and -= already did. At 96ebb1a1d, the formatter produced s..= "b", because the character following the separator is the first . of ..= and . is in NO_SPACE_BEFORE (issue #1114). Single-quoted string normalization interacts with the same area: local s = 'x' .. 'y' was normalized to double quotes, but the first pass also dropped the operator space to "x".. "y", and only a second format restored it (issue #1097).

Formatting Idempotency: Why Formatting a Luau File Twice Must Match Once

A formatter must be a fixed point of its own output: running it on an already-formatted file must reproduce that file character for character. This is not an optimization target—it is the acceptance bar. Issue pages in this project say so directly, requiring that “formatting twice gives the same text as formatting once for every format fixture.”

Idempotency matters because format-on-save runs the formatter on every save. If the formatter is not a fixed point, a whitespace position can flip back and forth on each save. That creates a permanent noise diff and makes code review useless—reviewers cannot tell a real change from the formatter toggling a space.

The clearest failure case is issue #1108, reported at 34406f45f. local t = {["k"] = "v"} becomes {[k]= v} on the first pass, and the second pass restores {[k] = v}. The root cause is the category mismatch described earlier: the space after ] is captured as ExtraWhitespace and deleted in one spelling, while in the other spelling the capture is empty and only a zero-width OptionalWhitespace remains, which is widened to a space. Each pass undoes the last.

A second, more dangerous class exists: output that is stable but wrong. A second-pass check cannot detect that a misspelling has been frozen in place. The generic and optional-type cases are exactly this—Array <number > and number ? were both verified to be stable on a second pass, so no round-trip test would have caught them. Idempotency is necessary, not sufficient.

A two-pass idempotency test you can run on any Luau formatter

The test is mechanical. You do not need to read the formatter’s source or trace the maintainer’s code paths.

Save a copy of the file you want to check.
Format it once and save the result as pass 1.
Format pass 1 and save the result as pass 2.
Diff pass 1 against pass 2. Any byte of difference means the build is not a fixed point.

In this repository, the same check runs in-process. formatSource in packages/sparkdown-language-server/src/tests/formatter/formatSource.ts drives getDocumentFormattingEdits over a source string, which is how the reproductions above were measured. deltaFormatEquivalence.test.ts passes only when the invariants hold. You can exercise a single file with node scripts/test-suite.mjs run packages/sparkdown-language-server src/tests/formatter/<your-test>.test.ts --wait 1500.

Two habits make the test more useful. First, run three passes instead of two when a quote-normalization change is involved—the 'x' .. 'y' case needed a second format before the operator space reappeared. Second, treat “pass 1 equals pass 2” as only half a result. Inspect the text itself for spellings nobody would write.

When a Luau Formatter Rewrites Good Code Into Odd-Looking Spelling

The most visible symptom is a keyword glued to the brace or string that follows it. return {1} becomes return{1}, for k in {1, 2} do becomes for k in{1, 2} do, if c then {1} else {2} becomes then{1} else{2}, and return [[s]] becomes return[[s]] (issue #1110, reported at 34406f45f).

The code still runs, but the formatter has rewritten common, well-formed Luau into a spelling that reads like a function call—f{1}—which is not how anyone writes the language. The reported cases cover four keywords: return, in, then, and else. The result is stable on a second pass, so nothing self-corrects.

The second symptom is type-layer output that is stable and wrong: Array <number >, number ?, and y:: number from the previous section. All three survive a round-trip check.

A related trap is confusing brace bodies with tables. The { ... } bodies of layout, style, animation, theme, component, morph, and screen blocks are indented by block depth, and a closing } lines up with its header. They are not Luau tables, so the one-line table spacing rule does not apply. A one-line block gets { a = 1; b = 2 }, with one space after each ;, one space before a block’s {, and one on each side of an optional =. Issue #1226 explicitly leaves those brace blocks out of its scope.

Is it my code or the formatter build? A short diagnostic order

Work through these in order, and stop at the first one that matches.

Is the diff whitespace-only? If so, the formatter is behaving within its design. If tokens moved, were renamed, or a string’s contents changed, stop—that is a defect, and you should not commit the result.
Does the output change on a second run? Format the result again and diff. A difference means a broken fixed point; record the input, the build, and the two outputs.
Is the output stable but spelled unusually? If return{1} or Array <number > comes back unchanged the second time, the problem is the implementation’s spacing rules, not your source. Rewriting your code to match it will only make the file harder to read.

The ImpowerGames/impower root cause and umbrella issue #1104

Most of these cases converge on one underlying defect class. Issues #1108, #1110, #1095, #1099, and #1114 are each filed under the umbrella item #1104 and fixed on pull request #1107. They are different surface symptoms of the same whitespace-classification problem, found by successive review rounds of that PR.

The structural reason they cluster is that the formatter historically decided spacing by looking at adjacent characters, while the classification lives on parse-tree nodes. FormattingAnnotator forces a trailing space for keywords in KEYWORDS_REQUIRING_TRAILING_SPACE, but only when the next character is (. A keyword followed by { or [ therefore fell through to the call-gluing rule, and else was absent from the set entirely. The ..= operator was missing from the forced-space table that already covered ...

The tracker also carries the proposed regression net for this class. Issue #996 describes a layout-variant oracle: take Luau code that already runs green, mechanically rewrite it into one-line, glued-keyword, semicolon, and comment layouts that Luau defines as equivalent, run each rewrite through the conformance harness, and require the same output text, the same returnedOK, and no new diagnostic. The motivation is that 22 upstream conformance fixtures passed end to end while ten layout-specific Luau bugs filed between 2026-09-26 and 2026-09-27 existed, because those fixtures are all written in one tidy layout.

Version and Status Caveats: What’s Fixed and What’s Still Open

Every rule in this article is tied to a specific issue and commit, because formatting defects are fixed continuously and different builds can behave differently. The commits cited above are 34406f45f (the bracketed-key spacing toggle and the keyword gluing), bfb1197a6 (generics, ::, single-quoted strings), c51ea0bfa (optional ?), 96ebb1a1d (..=), and 871116e (the line numbers cited for the table-spacing rule).

Before treating any row of the reference table as current behavior, re-test it against the build you actually have. The behavior descriptions here reflect the state of the code at those commits, and the issue pages show the related work landing on pull requests #1077, #1107, and #1245.

Two items were still shown as open at the time of writing in early October 2026. #1227, which formats brace bodies by brace depth across the seven block constructs in the Sparkle UI system, is open with a linked pull request. #996, the Luau conformance layout-variant oracle, is also open.

One scope limit applies to everything here: the whole corpus comes from the tracker of a single repository, ImpowerGames/impower. These rules describe the conventions of one implementation—Sparkdown, as shared by the VS Code extension and the web editor—not an official standard of the Luau language.

Conclusion

A trustworthy Luau formatter changes only layout, never semantics, and it must be a fixed point of its own output. You can verify both properties yourself: check that the diff contains nothing but whitespace, and check that a second run produces a byte-identical result to the first. Start by formatting a scratch file with the constructs you use most—one-line tables, optional types, generics, ::. An online Luau formatter is the zero-setup scratchpad for that first pass: paste the script, get back cleanly indented code with type annotations preserved, then compare the spacing decisions against the reference table above. Only then turn on format-on-save. When a file keeps changing on the second run, record the issue and the build version instead of rewriting your code to match the formatter.

FAQ

Why does formatting my Luau file twice give a different result than formatting it once?

The formatter is not a fixed point: a whitespace position is deleted on one pass and restored on the next. The typical cause is that the same position is classified as extra whitespace in one spelling and optional whitespace in another (issue #1108). Diff the two outputs and report it to the maintainers rather than editing your code.

Does running a Luau formatter change what my code does?

By design, it does not. It changes whitespace, line breaks, and space inside braces, and never token order or string contents. When the tool is working correctly, a formatting diff is always a whitespace-only diff. If you see keywords reordered or a string rewritten, that is an implementation defect—do not commit it.

What spacing should a one-line Luau table use inside its braces?

One space after { and one before }, giving { a = 1 }, { 1, 2 }, { [k] = v }, and { x: number }. An empty table stays {}, and { } collapses to {}. Interpolation and binding braces stay tight—"HP: {hp}", a backtick string’s {x}. Multi-line tables and the trailing-comma rule are unchanged (issue #1226).

How do I run a Luau formatter on save in VS Code?

Point Luau’s default formatter at Sparkdown’s document formatter so no other extension competes for the language, then enable editor.formatOnSave. In the web editor, Mod-S triggers the same path manually. Format one file by hand and read the diff before you enable automatic saving, so the first run cannot touch valid code unsupervised. And if you just need one snippet cleaned up with no editor configuration at all, an online Luau formatter does the job in the browser—free, no registration, with Roblox style-guide defaults.

Why did formatting turn `return {1}` into `return{1}`?

The separator rule glues a call-like opener—(, [, or {—to the preceding word character so that f(x), a[1], and f{1} stay tight. FormattingAnnotator exempts certain keywords with a forced space, but only when the next character is (. else is also missing from that keyword set, so then{1} and else{2} glue the same way (issue #1110). The code still runs, but it reads like a function call; this is an implementation defect, not a problem with your source.

2026年10月9日

Date Calculator Between Two Dates: Days & Workdays

A date calculator between two dates gives you the exact span between any two calendar dates—total days, weeks, months, and years. Enter a start date and an end date, choose whether the end day counts, and it handles leap years for you.

How to Use a Date Calculator Between Two Dates (Step by Step)

A date calculator between two dates turns two calendar dates into a precise duration. It does the math that manual counting often gets wrong: different month lengths, leap years, weekends, and whether the final day belongs in the total. Most tools return the result in several formats at once, so you can pick the unit that fits the task.

Step 1: Enter Your Start Date & End Date Inputs

Open the tool and find the two required fields: Start Date and End Date. Put the earlier date in Start Date and the later date in End Date. If your tool accepts dates in any order, the result is still an absolute span. Use ISO-8601 format when you can, such as 2026-10-01, because 03/04/2026 means April 3 in most countries and March 4 in the US. CalcOpenly notes that ISO dates avoid that day-and-month ambiguity.

Step 2: Decide Whether the End Date Counts

Look for an “include end date” or “count end date too” toggle. Most calculators default to exclusive counting: end date minus start date, so the final day is not counted. Turn the toggle on when both the first and last day count, such as leave from Monday to Friday or an event that runs through its closing day. This one setting changes the answer by exactly one day.

Step 3: Read Total Days, Weeks, Months, and Years

Read the output in four forms: total days, total weeks and leftover days, calendar-style years/months/days, and business days. For example, CalcOpenly shows that 1 October 2026 to 30 December 2026 is 90 total days, 0 years 2 months 29 days, 12 weeks and 6 days, and 64 business days. Use that worked span as a sanity check. If a tool returns a different total for the same dates, check its end-date and holiday settings before you trust it. The Gregorian calendar is the default basis for these counts.

Inclusive vs Exclusive Counting: Does the Calculator Count the End Date?

The default convention in most date calculators is exclusive: the calculator counts the first date but not the ending date. As PK, DQYDJ notes: “it counts the day of the first date but not the ending date.” That is the same convention as subtracting one date from another in a spreadsheet, which is why adding one day to the end date often produces the “missing” day.

Four Common Day-Count Conventions Compared

Four conventions cover most real-world uses. Subtraction, the calculator default, counts the start date and leaves out the end date. Inclusive counting counts both the start and end dates. Clear days exclude both ends. US federal court deadlines use a fourth rule: exclude the trigger day, count every day including weekends and holidays, and include the last day unless it falls on a weekend or holiday. CalcOpenly shows that the same 3–10 March 2026 pair can be 7, 8, or 6 days depending on the convention.

Why ‘3 March to 10 March’ Can Be 6, 7, or 8 Days

Take Tuesday 3 March 2026 to Tuesday 10 March 2026. Subtracting the dates gives 7 days. Counting both ends gives 8 days. Counting neither end gives 6 clear days. Contracts, leave policies, and statutes each pick a convention, and choosing the wrong one moves a deadline by a day. The fix is to state the convention in writing, not to assume the calculator’s default matches the rule you are working under.

US Federal Court Deadline Rule: FRCP 6(a)

US federal courts follow Federal Rule of Civil Procedure 6(a). The rule excludes the day of the triggering event, counts every day including weekends and holidays, and includes the last day—but if that last day is a Saturday, Sunday, or legal holiday, the period runs to the next day that is not. A 10-day period triggered on Wednesday 4 March 2026 would end on Saturday 14 March, so it moves to Monday 16 March. This is a non-default convention, which is why a standard calculator’s exclusive-end result should not be used for court deadlines without adjustment.

How Leap Years and Unequal Months Affect Your Result

Leap years and uneven month lengths are the two biggest reasons manual date math fails. A leap year adds one day to any span that crosses February 29. Unequal months mean a month is not a fixed number of days, so month-based output depends on where the span starts.

Why February 29 Adds One Day

The Gregorian calendar adds February 29 in years divisible by 4, except century years not divisible by 400. According to datecalculatorbetweentwodates.com, January 1, 2024 to January 1, 2025 is 366 days, while January 1, 2025 to January 1, 2026 is 365 days. A span that crosses February 29 gains one day; a span that does not cross it does not. That single day can change a payroll period, an interest calculation, or a contract deadline.

Month-End Clamping: Jan 31 + 1 Month = Feb 28 or 29

Month addition uses end-of-month clamping. If the target month does not have the same day number, the result becomes the last day of that month. CalcOpenly gives the example of 2024-01-31 to 2024-03-01: the total is 30 days, which reads as 1 month and 1 day because one month after 31 January is 29 February in a leap year. In a non-leap year, 31 January plus one month becomes 28 February. The same rule explains why 31 January to 1 March 2024 is not a clean two months.

Gregorian Calendar: The Default Basis for Every Count

Standard date calculators use the Gregorian calendar for all dates, including dates before the calendar was widely adopted. The Gregorian calendar divides the year into 365 days, with 366 in a leap year, and splits it into 12 months of 28–31 days. Its leap-year cycle is why a calculator can return an exact result while manual counting drifts by a day or more.

Calendar Days vs Business Days: What Changes?

Calendar days count every date on the calendar, including Saturdays, Sundays, and holidays. Business days, also called working days, usually count Monday through Friday only, and may exclude public holidays. The distinction matters when you are measuring elapsed time versus time available for work.

How Business Day Counts Treat Weekends

By default, business day counts treat Saturday and Sunday as non-working days. A tool may also let you change the weekend definition—for example, Friday–Saturday—but the common US setting is Saturday–Sunday. CalcOpenly notes that whole-day counts are unaffected by time zones and daylight saving time; only hour-level counts change when a clock change falls inside the span. If you need Monday–Friday only, use the business-day output rather than the total-days output.

Do Business Day Calculators Exclude US Public Holidays?

Most basic calculators exclude weekends only and leave public holidays to the user. File Toolbox states plainly that its business-day count skips Saturdays and Sundays only and does not remove public holidays. Some tools offer a US federal holiday option or a custom holiday list; HowLongAgoGo says its business-day calculator includes public holidays for multiple countries, including the US. Check whether observed holidays are included before relying on the result for payroll or legal deadlines.

The Weekend Holiday Double-Count Trap

A holiday that falls on a weekend should not be subtracted twice. If a Saturday holiday is observed on Friday, you subtract one working day, not two. CalcOpenly illustrates the principle with England and Wales: over Christmas 2026, 26 December is a Saturday and the Boxing Day bank holiday moves to Monday 28 December, so listing 25, 26, and 28 December removes three days, not four. For US dates, the same logic applies to any federal holiday whose observed date shifts to a weekday.

Weeks, Months, and Years Breakdown: Why 90 Days Isn’t Always 3 Months

The calendar-style output expresses total days as X years, Y months, and Z days. That format is useful for human-readable durations, but it is not a fixed fraction of a year. Months have 28–31 days, so the same number of total days can produce different month-and-day labels depending on the start date.

Reading the Calendar-Style Output

For the days between two dates such as 1 October 2026 to 30 December 2026, the result is 90 total days, 0 years, 2 months, and 29 days, or 12 weeks and 6 days. CalcOpenly also shows 2,160 hours for that span. Additional outputs may include minutes and seconds, calculated as days × 1,440 and days × 86,400. Read the calendar-style line as a convenience label, not as a substitute for the total-day count.

When to Trust Total Days Instead

Use total days when the deadline, billing period, or contract is written in days. In the CalcOpenly example, two spans with the same number of days can show different months-and-days figures because of month-end clamping. If the agreement says “30 days,” use 30 days. If it says “one month,” use the month figure and check the end-of-month case. Total days is the safest unit for legal deadlines, payroll, and interest calculations.

Add or Subtract From a Date: The Companion Tool

The add/subtract side of the date calculator answers a different question: what date is X days, weeks, months, or years from a starting point? It is the companion to the between-dates calculator, not a replacement for it. The between-dates calculator measures the span between two known dates; the add/subtract tool projects a new date from one known date and a duration.

Add/Subtract Years, Months, Weeks, or Days

Enter a start date, choose add or subtract, and enter the amount and unit. The tool uses the same Gregorian calendar and end-of-month clamping rules as the between-dates calculator. For example, 2024-01-31 plus one month equals 2024-02-29 in a leap year, not March 2 or March 3. When the target month lacks the start day, the result falls on the last day of that month.

Related Tool: Age Calculator

An age calculator applies the same date arithmetic to a birth date and a reference date. It returns exact age in years, months, and days, and may also show total days alive, weeks, and the next birthday. Event countdown tools use the same span logic in the opposite direction, counting down to a future date such as a holiday, wedding, or product launch. Keep the between-dates calculator focused on the two-date span and link out for add/subtract, age, and countdown queries.

US Scenarios: Payroll, Court Deadlines, and Project Planning

US users often need more than a simple day count. Payroll, court deadlines, and project schedules depend on business days, holiday observance, and a clearly stated counting convention. The same two dates can produce different answers in each context if the convention is not defined.

Federal Court Deadlines

Federal court deadlines follow FRCP 6(a): exclude the trigger day, count weekends and holidays, include the last day, and roll forward if the last day is a weekend or holiday. A 10-day period triggered on Wednesday 4 March 2026 ends on Monday 16 March 2026 because the natural end date is Saturday 14 March. A standard calculator set to exclusive-end counting would return 10 days but would not perform the roll-forward, so use a court-deadline tool or apply the rule manually.

Payroll and Billing Cycles (Weekly, Biweekly, Semi-Monthly)

Weekly, biweekly, and semi-monthly payroll cycles depend on business-day counts and holiday observance. Use business-day output to estimate pay periods and billing periods, then subtract any US federal holidays that fall on weekdays. If the holiday is observed on a different date, adjust the count so the holiday is not double-counted. The same logic applies to invoice due dates and notice periods.

Project Planning with Business Days

Project schedules should use a holiday-aware business day count, not a simple Monday–Friday filter. For 2026, start from 261 weekdays and subtract US federal holidays that fall on weekdays; verify observed dates for Saturday and Sunday holidays. CalcOpenly reports 261 weekdays in 2026 and, for England and Wales, 253 working days after 8 bank holidays, which shows how much a jurisdiction’s holiday list changes the result. State the counting convention—inclusive, exclusive, or clear days—in the project plan so no one has to guess.

How to Verify a Date Calculator’s Result Yourself

A date calculator is only as reliable as its counting convention and its date arithmetic. You can verify the days between two dates without writing a full date library by using serial day numbers, spreadsheet functions with caveats, or public reference algorithms. The goal is to confirm the total-day figure first, then check the business-day and holiday adjustments.

Manual Check: Serial Day Numbers

Convert each date to a serial day number, then subtract. CalcOpenly describes the method as counting days since 1 January 1970 in the proleptic Gregorian calendar: 1 October 2026 is day 20,727 and 30 December 2026 is day 20,817, so the difference is 90 days. This method handles leap years and month lengths automatically. If your manual result differs, check whether you counted the end date and whether the dates were entered in ISO order.

Excel DATEDIF and NETWORKDAYS Caveats

Excel’s DATEDIF can return incorrect results for specific edge cases. As Dave Bruns, Exceljet, notes: “The DATEDIF function can return incorrect results with date pairs that touch specific edge cases.” Exceljet suggests a custom lambda function as a workaround. NETWORKDAYS has a different trap: it counts both the start and end dates by default. According to Microsoft’s NETWORKDAYS example, 1 October 2012 to 1 March 2013 returns 110 working days, while a calculator with a default exclusive end date returns 109 for the same dates because 1 March 2013 is left out. NumPy’s busday_count also excludes the end date.

Open Standards and Reference Implementations

For independent verification, use a published standard and a public algorithm. ISO 8601-1:2019 defines date and time representations for information interchange. Howard Hinnant’s days_from_civil algorithm provides a chrono-compatible low-level date calculation that many implementations use. A calculator that publishes its last-reviewed date and states its default counting convention gives you the two pieces of information you need to trust or challenge its result.

Conclusion

A date calculator between two dates is only as reliable as the counting convention behind it. Total days, inclusive versus exclusive rules, leap years, and business-day definitions all change the answer. Before you rely on a result for payroll, court, or project planning, confirm whether the tool includes the end date, excludes US federal holidays, and uses the Gregorian calendar. Run one worked example—2026-10-01 to 2026-12-30 = 90 days and 64 business days—to verify the tool’s behavior before you use it for a real deadline.

FAQ

Does the calculator count both the start date and the end date?

Most date calculators default to exclusive counting: end minus start, so the end date is not counted. An “include end date” toggle adds one day, making the count inclusive. Check the convention before using the result for contracts or legal deadlines.

How does the date calculator handle leap years and February 29?

It uses the Gregorian calendar, which adds February 29 in years divisible by 4, except century years not divisible by 400. A span crossing February 29 gains one day; for example, January 1, 2024 to January 1, 2025 is 366 days. Month additions that land on February 29 are valid only in leap years.

How many working days are there in 2026?

2026 has 261 weekdays, Monday through Friday, according to CalcOpenly. Subtract US federal holidays that fall on weekdays to get the working-day count; verify observed dates for weekend holidays. The final number depends on the jurisdiction and whether observed holidays are excluded.

Do business day counts exclude US public holidays?

Most basic calculators only exclude weekends and leave holidays to the user. Some tools offer a US federal holiday option or a custom holiday list. Always verify whether observed holidays—such as a Friday observance for a Saturday holiday—are included in the exclusion.

What is the difference between calendar days and business days?

Calendar days count every date, including weekends and holidays. Business days typically count Monday–Friday only, and may exclude public holidays. Use calendar days for elapsed time; use business days for project schedules, payroll, and legal deadlines.

Can I calculate the number of days between two dates in the past or the future?

Yes. The calculator works for any two valid Gregorian dates, past or future. The result is always an absolute span; direction only matters for add/subtract tools. For future dates, confirm whether daylight saving or time zone changes matter—whole-day counts do not.

2026年10月9日

Resize GIF Without Losing Quality, Speed, or Transparency

To resize a GIF, drop the animation into a browser-based GIF resizer, type your target width in pixels with the aspect-ratio lock on, and export. Downscaling cuts file size while frame delays, transparency and looping stay intact — but shrinking never adds detail, so always start from your largest source file.

How Resizing an Animated GIF Actually Works — and What Stays Intact

Resizing an animated GIF changes exactly one thing: the pixel canvas. Everything else in the file — how long each frame stays on screen, how many times the animation loops, which colour index is marked transparent — gets copied through untouched by a competent resize operation.

Understand that, and most of what follows in this guide falls into place. AREM Labs states it directly: a standard pixel-dimension resize adjusts only the canvas width and height while leaving frame delay values and looping metadata untouched. As long as the file passes through a tool that preserves frame timing arrays, playback speed stays identical to the original.

The complication is that you’re not resizing one image. You’re resizing a stack of them.

Why a GIF Is Not Just a Bigger PNG

A GIF stores every frame as its own separate, palette-indexed image. According to ShotEdit, a three-second screen recording at 15 frames per second is 45 stored images. That’s why file size grows with duration, frame rate and pixel area all at once — and why a short clip that would be a 400 KB MP4 turns into a 6 MB GIF.

Each of those stored frames carries its own 256-colour palette. GIF supports a maximum of 256 colours per frame, and no amount of scaling changes that ceiling. When a resizer redraws a frame at a new size, it has to re-quantise the colours to fit that palette again. This is the mechanical reason gradients and dither patterns are where visible banding shows up, even when you’re only shrinking.

What Survives a Resize: Frame Delay, Loop Count, Transparency

A resize operation doesn’t touch the frame delay array, the loop/NETSCAPE extension, or the transparent colour index. Those are separate data structures in the file, and a pixel-level resize has no reason to rewrite them.

That’s why playback speed, loop count and transparency survive a correctly executed resize. It’s also why they break when a tool takes a different route — extracting every frame as a separate still, resizing the stills, and rebuilding the animation from scratch. Rebuilding is where timing drifts, loops reset to defaults, and the transparent colour index gets dropped or replaced with a background colour.

How to Resize a GIF in a Browser, Step by Step

This is the primary workflow, and the order matters. Skip a step and you get a specific, predictable failure.

Step 1 — Start from the largest, cleanest source you own. Resizing never adds detail, so your source file defines the ceiling on quality. If you have a video export and a small GIF, resize the video export down rather than upscaling the GIF.

Step 2 — Open a browser-based GIF resizer and load the file. EZGIF and similar no-signup tools cover resize, optimize and crop in one place, so you can complete the whole workflow without moving between applications or formats.

Step 3 — Enter width in pixels with the aspect-ratio lock ON. Let height calculate itself. Typing both numbers manually is how people stretch GIFs. AREM Labs lists unlocking the aspect ratio during scaling as the first common mistake: entering custom width and height values without the lock stretches characters, distorts circular products, and ruins brand presentation.

Step 4 — Pick a resampling method deliberately. Use smooth interpolation — Lanczos, bicubic or bilinear — for footage, reaction clips and photos. Use nearest neighbour for pixel art, UI captures, emoji and anything with hard one-pixel edges. ConvertICO labels these as “Photo and video” (Lanczos), “Smooth pixel art” (xBR/hqx) and “Crisp pixels” (nearest neighbour), and notes that crisp-pixel scaling uses whole-number scales so every original pixel grows by the same amount.

Step 5 — Preview before exporting. Check the busiest frame in the animation for banding, then compare the before and after file size. The busiest frame is where palette re-quantisation shows first.

Step 6 — Only if the export still misses the cap, move to the GIF compression levers. Resize stays first because it’s the most predictable reduction for the least visible quality cost.

Know the ceilings. Browser tools impose input limits — ConvertICO’s GIF upscaler accepts GIFs up to 25 MB and 500 frames with a maximum of 4000 px on any side, and other tool pages in the same category cite comparable figures. Oversized sources need pre-trimming before they will load at all.

The Order That Matters: Resize First, Compress Second

Resize, then compress. Not the other way around.

AREM Labs is explicit about why: compressing a file first introduces compression artifacts that get magnified and blurred during dimensional downscaling, and applying colour optimisation as the final step avoids that. ShotEdit agrees on the ordering logic, calling resize “usually the most reliable reduction when a GIF must hit a hard limit” and noting it costs the least visible quality per kilobyte saved.

Three Mistakes That Ruin the Output

Unlocking the aspect ratio. Custom width and height values without the lock stretch the subject. Keep the lock on and type one number.

Relying on browser CSS for downscaling. Uploading a 2000 px wide GIF and setting its display width to 400 px via HTML or CSS forces every visitor to download the full payload. AREM Labs puts the figure at roughly 15 MB in that example. Resize the source file itself.

Resizing without checking the frame count first. Scaling a 500-frame animation still produces an oversized file even at low resolutions. Trim unneeded frames before scaling, not after.

How Much Does Resizing Actually Shrink a GIF?

The pixel math is the whole story, and it’s simpler than most guides make it sound. Halving both dimensions removes 75% of per-frame pixel area. That’s the primary source of the weight drop.

AREM Labs puts it plainly: resizing from 1200×800 to 600×400 cuts the total pixel count per frame by 75 percent, which drastically reduces overall byte size. The weight doesn’t fall by exactly 75% — palette data, headers and per-frame metadata don’t scale with area — but the pixel reduction is what drives the result.

Lossy re-encoding stacks on top of that, but it plateaus fast. According to ShotEdit, a 228 KB clip dropped a further 7% at lossy 30, 15% at lossy 80, and 25% at lossy 200. In other words, tripling the lossy strength from 80 to 200 bought roughly ten additional percentage points of savings — and that’s the point at which dithering artifacts typically become visible.

The Pixels-Are-the-File Rule

GIF file size is driven by frame count multiplied by pixel area multiplied by palette complexity. Resizing touches only the middle term.

This is why the same resize produces dramatically different results on different files. A GIF that was already reduced to a small palette and a low frame rate has little left to give. A GIF freshly exported from a video with a full 256-colour palette per frame has a lot. Two GIFs at identical dimensions can still differ several-fold in weight, so dimensions alone never predict whether you’ll clear a file cap.

Why a Second Round of Compression Barely Helps

GIF has no true inter-frame compression. ShotEdit’s explanation is the clearest available: GIF stores only the changed rectangle of each frame beyond that, so once a recording has gradients, dithering or camera motion, almost every pixel changes between frames and the optimisation stops helping.

That leaves very little redundancy for a second optimisation pass to find. ShotEdit states that palette reduction and lossy smoothing are not cumulative in a useful way, and that re-running the same compression settings returns almost the same file. The practical advice that follows: change a setting instead — resize the frames or lower the colour count — rather than repeating an identical pass.

One exception worth knowing: flat UI recordings and screen captures of interfaces with solid fills barely shrink at any lossy setting, because there’s no dither noise left to smooth away. ShotEdit notes that a two-colour loading spinner is already close to the smallest a GIF can be.

Target Sizes and File-Weight Limits by Platform, Checked October 2026

One table, several channels, with the caveats that most single-source guides leave out. Platform limits drift, and Discord is the clearest current example.

The One-Page Size + Weight + Format Table

Platform / Use Case	Target Dimensions	Target Weight	Transparency	Source & Check Date
Shopify / WooCommerce product body	600×600 to 800×800 px	Under 2 MB	Supported	AREM Labs, 2026-09-16
Amazon A+ Content (full-width banner)	970×600 px	Under 3 MB	Supported	AREM Labs, 2026-09-16
Email newsletters (Klaviyo / Mailchimp)	480×480 to 600×400 px	Under 1 MB	Supported	AREM Labs, 2026-09-16
Etsy product descriptions	750×500 px	Under 1.5 MB	Supported	AREM Labs, 2026-09-16
X / LinkedIn inline feed	800×450 to 1200×675 px	Under 5 MB	Supported	AREM Labs, 2026-09-16
UI / software documentation tooltips	400×300 px	Under 800 KB	Supported	AREM Labs, 2026-09-16
Discord chat (free account)	—	8 MB or 10 MB — sources conflict	Supported	Wondershare, updated 2026-09-23; ShotEdit, 2026-09-05
Discord chat (Nitro Classic / Nitro)	—	50 MB / 100 MB	Supported	Wondershare, updated 2026-09-23
Discord animated emoji	128×128 px	Under 256 KB	Supported	Wondershare, updated 2026-09-23
Slack channel	—	Uploads fine, but over ~2 MB loads slowly	Supported	ShotEdit, 2026-09-05
GitHub issues and pull requests	—	10 MB per file	Supported	ShotEdit, 2026-09-05
Email attachment (whole message)	—	Commonly 20–25 MB	Supported	ShotEdit, 2026-09-05

The Discord conflict deserves to be stated plainly rather than smoothed over. Wondershare’s guide, updated 2026-09-23, lists 8 MB for free accounts — while the same article’s own body text still refers to itself as a 2025 guide. ShotEdit, checked 2026-09-05, lists 10 MB for a free Discord account. Two sources, both recent, disagree by 2 MB. Treat the figure as tier- and date-dependent, and verify against Discord’s own help centre before you commit a workflow to it.

For Web Pages: Why GIF Weight Is a Core Web Vitals Problem

An inline e-commerce product animation is best served at 480–800 px wide, per AREM Labs. That range keeps details sharp on mobile screens and desktop monitors while keeping the payload light enough to maintain fast Core Web Vitals and quick checkout loading.

This matters more for GIFs than for stills because a GIF is downloaded in full by every visitor. Oversized GIF dimensions slow mobile page loading, consume customer data plans, and cause layout shifts on responsive themes — and a layout-shift problem is a Core Web Vitals problem, not merely a storage problem.

AREM Labs frames the fix directly: resize the GIF to the exact pixel dimensions of its container rather than uploading a large file and scaling it down in CSS. If the container is 640 px wide and the animation is 1920 px wide, the answer is a 640 px asset, not a 1920 px asset with a width attribute.

Discord Emoji at 128×128 and 256 KB: The Strictest Target

Animated emoji is the tightest real-world constraint in this table. Wondershare states that animated emoji must be 128×128 pixels, and that regardless of dimensions, all emoji uploads — static or animated — must be under 256 KB.

Meeting both at once is a two-stage job: get the dimensions right first, then attack the weight. This is exactly why resize-then-recolour is the reliable path — 128×128 alone will often not clear 256 KB for a detailed animation, so colour reduction and frame dropping follow the resize. Note also that animated server emoji require Nitro to display as animated, per the same source.

Does an Online GIF Resizer Upload My File?

It depends entirely on the tool’s architecture, and the two architectures are easy to tell apart once you know what to look for.

Server-side tools upload your file, process it on a remote machine, and return the result. Client-side tools process everything on your device — the pixel data never leaves the browser. ImageLean’s GIF resizer is built on the client-side model: resizing runs in your browser, so the animation is not uploaded anywhere. ShotEdit describes its own architecture explicitly: compression runs locally with gifsicle compiled to WebAssembly, and the file never leaves your device.

The practical stakes aren’t abstract. Unreleased product recordings, client footage under NDA, internal dashboards, and anything governed by a company data policy should not be handed to an unknown server. ShotEdit names unreleased product recordings and customer data as the specific cases where local processing matters.

How to Verify a Tool Really Processes Locally

You can test this in about thirty seconds rather than trusting a privacy badge.

Load the tool, start a resize or compression on a reasonably large GIF, then disconnect your network — pull the Wi-Fi or unplug the ethernet. If processing is genuinely client-side, the job finishes normally. If it’s server-side, the job dies when the connection does.

Before uploading anything sensitive, also check three things: the tool’s privacy page, whether its output is re-encoded through a native engine or re-drawn from extracted frames, and whether it states a retention window. ConvertICO, for example, states that uploads and results get random names and are deleted automatically within four hours — a server-side tool with a disclosed retention policy rather than a no-upload tool.

Resize vs Compress vs Crop vs Trim: Pick the Right Lever First

Four terms, four different variables in the file. Confusing them is why people crop a GIF, see no size change, and conclude the tool is broken.

Resize changes canvas dimensions. Compress changes the colour or lossy budget. Crop changes the visible area. Trim changes duration.

The recommended execution order is: resize → tune lossy strength → reduce colours → drop frames. Stop the moment the file clears the cap. ShotEdit gives the reasoning behind the ordering — resize first because it’s the most predictable reduction and costs the least visible quality per kilobyte saved, then lossy strength until artifacts appear in flat areas, then colour count while watching gradients for banding, then frame dropping last because choppy motion is usually the first thing a viewer notices.

Cropping deserves a specific warning. It can leave file weight almost untouched if the frame count and per-frame palette stay the same, which is why the experience of “I cropped it and it’s still too big” is so common. Crop to fix framing; don’t expect it to fix weight.

Trimming is the opposite: it cuts weight roughly in proportion to the frames removed, making it the bluntest but most effective lever for long recordings.

The stop-loss rule. When a long recording still misses the target at acceptable quality, change format rather than degrading further. ConvertICO reports that in its tests a 2x animated WebP came in at under one third of the size of the equivalent 2x GIF while holding more detail. Animated WebP keeps full colour and smooth transparency; MP4 is smallest of all but has no alpha channel, so transparent areas become white. ShotEdit’s blunt version of this advice: if a GIF still won’t fit after the strongest compression setting, the clip is too long for the format, and the same recording as MP4 is routinely five to ten times smaller at better quality.

Keep GIF output only where the destination demands a .gif file — chat clients, forums, some email clients, and template-bound CMS embeds.

A Decision Table: Which Lever Fixes Which Problem

Problem	Lever	Why
Wrong display size on the page	Resize	Changes the canvas; also the largest predictable weight win
Over a hard upload cap, dimensions already correct	Compress (lossy strength)	Reduces palette rounding noise; biggest win on video-derived GIFs
Gradients banding after compression	Reduce colours (less aggressively)	Palette reduction is what causes banding
Too long a duration for the format	Trim / drop frames	Size falls close to proportionally with frames removed
Unwanted borders or desktop chrome visible	Crop	Fixes framing only — expect little or no weight change
Still over the cap at acceptable quality	Change format	Animated WebP keeps colour and transparency; MP4 is smallest but has no alpha

Batch Resizing GIFs: Desktop Tools, CLI and Code

When you have fifty emoji to prepare or a product catalogue of animated swatches, single-file resizing stops being practical. Three paths cover almost every batch scenario.

Desktop Batch Tools vs gifsicle vs sharp

Desktop batch path. Light Image Resizer version 7.6.6.178, released 2026-09-09, lists animated GIF among its supported formats and runs on Windows 11, 10 and 8.1. Its v7 feature set includes shell integration for the Windows context menu, pre-defined profiles including file-size targets such as 256 KB, 1 MB and 2 MB, and a batch converter that processes folders and subfolders.

CLI path. gifsicle’s --resize with an explicit resampling method is scriptable, deterministic and preserves frame delays — the right choice for dozens of emoji or asset variants where you want the same operation applied identically every time. Deterministic output matters more than speed once you’re generating a set that has to look consistent.

Code path. The sharp npm package resizes GIF alongside JPEG, PNG, WebP, AVIF and TIFF in Node.js, and at version 0.35.5 more than 10,000 other projects in the npm registry depend on it. That dependency count is a useful proxy for how battle-tested the pipeline is — but when your own code re-encodes, verify frame-delay and palette handling yourself rather than assuming the defaults match your source.

Mobile and one-off batches. Where no desktop or script is available, ImgPlay and Wondershare UniConverter handle batch work; Wondershare’s Discord guide describes using UniConverter’s converter interface to batch resize a set of GIFs to 128×128 in a single pass, with a frame-rate setting available to help stay under a 256 KB emoji ceiling.

Batch tip. Resize all variants from one master file and one preset. Emoji sets and product swatches stay dimensionally consistent only if they all come from the same source at the same settings.

The Extract → Resize → Reassemble Pattern (and Its Risks)

Historically, the only way to resize an animated GIF was to take it apart. A BleepingComputer forum guide from November 2006, with replies running as late as 2022, documents the classic workflow: IrfanView’s “Extract all frames” to split the animation into individual files, batch conversion to resize and reformat them, then unFREEz to reassemble the frames into a new animated GIF with frame delays measured in hundredths of a second — an entry of 1 giving a delay of 1/100 of a second, so 100 equals one second.

That thread is kept here explicitly as a dated reference, not as a current tool recommendation. The 83×83 px avatar figure in it was a 2006-era forum rule, and the tools are two decades old.

The pattern itself is still a useful mental model, and it’s also the failure mode this article’s diagnostic checklist keeps returning to. Extracting and reassembling frames is exactly the route that breaks things: frame order can scramble if you don’t grab the first file when dragging, timing drifts unless you manually tune the frame delay against the original, and — as one 2008 reply in that thread describes — transparency had to be re-selected frame by frame during reassembly, once on extraction and again on save. A true in-place resize avoids all three problems by never taking the animation apart.

Enlarging a GIF: What Upscaling Can and Can’t Do

Upscaling interpolates; it doesn’t invent detail. Expect softness, and expect hard edges and small text to suffer most. ConvertICO states this directly — the process uses proven image-scaling algorithms and never invents detail that wasn’t in your GIF, so faces and text are not changed.

The resampling choice decides how the softness looks. Lanczos, bicubic or bilinear for photographic frames produces a smooth, natural result that reads like a larger video. Nearest neighbour for pixel art preserves sharp square pixels exactly. xBR/hqx sits between them, redrawing blocky edges as clean curves for emoji, stickers, sprites and other small low-resolution graphics.

The practical ceiling. ConvertICO’s own testing calls 2x the sweet spot for most GIFs, and notes that beyond 3x the result looks soft unless the GIF is pixel art. That’s a useful boundary. Past roughly 3x, blur becomes unavoidable for anything that isn’t pixel art, and the better move is to go back to the original video, project file or vector source rather than upscaling the GIF.

One trade worth taking. In ConvertICO’s tests a 2x animated WebP came in under one third of the size of the equivalent 2x GIF. If the platform accepts WebP, upscaling into WebP is usually the better outcome than upscaling into GIF — you get more detail at less weight.

And the rule that never changes. Upscaling never helps a file-size problem. A 2x upscale has 4x the pixels in every frame, so GIF files grow quickly. Never use upscaling as a weight fix.

Choosing a Resampling Method by Content Type

Content type	Method	What it does
Clips, reaction GIFs, photos, gradients	Lanczos / bicubic / bilinear	Smooth and natural, like a larger video
Emoji, stickers, sprites, small low-res GIFs	xBR / hqx	Blocky edges redrawn as clean curves
Real pixel art, retro game graphics	Nearest neighbour	Every pixel becomes a sharp square

For downscaling the same logic applies with a different risk profile: nearest neighbour on photographic footage produces aliasing and shimmer, while smooth interpolation on pixel art or UI screenshots produces blur where you wanted crisp edges.

Resized GIF Looks Wrong? A Diagnostic Checklist

Every ranking page asserts that timing is preserved. None of them say how to prove it or what breaks it. This checklist does.

Symptom → Cause → Fix

Banding or posterised gradients. Colour reduction went too far, or the palette was re-quantised on export. Fix: raise the colour count or re-export from the original source. Photographic and gradient-heavy GIFs show banding quickly, while flat UI screenshots and line art often survive 64 or even 32 colours with no visible difference.

Everything looks soft. You upscaled past the source size, or smooth interpolation was applied to pixel art or UI screenshots. Fix: go back to the original video or source file, or re-export with nearest neighbour.

Edges shimmer or look blocky. Nearest neighbour was used on photographic footage, or the tool rebuilt the animation from extracted screenshots instead of writing scaled frames. Fix: switch to Lanczos or bicubic and use a tool that resizes in place.

File size barely moved. The GIF was already optimised. Fix: the real levers now are colour count and frame rate, not dimensions. ShotEdit notes that if a GIF has already been through a compressor, the easy savings are gone, and pushing lossy higher shrinks it further only at the cost of visible dithering artifacts.

Timing or loop count changed. The pipeline extracted and reassembled frames rather than resizing in place. Fix: compare frame delay values and loop count before and after, then switch tools. This is the specific failure documented in the 2006–2009 forum workflow, where frame delays had to be manually tuned up or down until the new GIF matched the original’s playback speed.

Transparency turned black or white. Either the destination format has no alpha channel — MP4 cannot store transparency, so those areas become white — or the transparent colour index was dropped during processing. Fix: re-export as GIF or animated WebP. The historical version of this failure is documented in the same forum thread, where transparency had to be re-selected manually on every frame during both extraction and saving because the tool converted it to a background colour by default.

The animation is static after uploading. Some platforms render animated avatars and emoji as still images without the right account tier. Wondershare notes that on Discord, animated server emoji and animated profile pictures both require Nitro; without it they appear static. The file itself may be fine.

Conclusion

Resizing a GIF changes pixels and nothing else — which is exactly why it’s the safest first move, and also why it’s capped in how much weight it can remove. Start from your largest source, resize with the aspect-ratio lock on, then check the export against the specific platform cap in the table above — and re-verify that cap against the platform’s own help centre, since tier limits shift and published figures for the same platform already disagree. If you still miss the target, move down the ladder: lossy strength, colour count, frame count. Switch to animated WebP — or MP4 when transparency isn’t needed — before you keep degrading a GIF that has nothing left to give.

FAQ

Does resizing an animated GIF reduce its file size?

Yes, but only through pixel area. Halving width and height removes about 75% of per-frame pixels, so weight drops roughly in proportion at first. It’s not linear forever — heavily optimised GIFs and flat UI recordings barely move. If weight must fall further, reduce colours or frame count rather than shrinking again.

Will resizing a GIF break the playback speed or the loop?

A true resize only rewrites the pixel canvas; the frame delay array and loop metadata are copied unchanged. Speed changes only when a tool extracts and reassembles frames, or stores delays in different units. Verify by comparing frame delay values and loop count before and after export.

Can I enlarge a small GIF without making it blurry?

No — upscaling interpolates; it cannot invent detail that was never captured. Use nearest neighbour for pixel art and UI, smooth interpolation such as Lanczos or bicubic for footage. Around 2x is the practical ceiling for most GIFs; beyond 3x, go back to the original video or source file instead.

How do I resize a GIF to 128×128 for a Discord emoji?

Crop to a square first so the aspect-ratio lock doesn’t distort the subject. Resize to 128×128 px, then check the weight against the 256 KB emoji ceiling. If it’s still over, reduce colours or drop frames — do not shrink below 128×128, since that is a hard requirement.

What’s the difference between resizing, cropping, trimming and compressing a GIF?

Resize changes canvas dimensions; crop changes the visible area; trim cuts frames and duration; compress reduces the colour or lossy budget. Only resize and trim reliably cut file size — cropping often leaves weight almost untouched. Order of use: resize, compress, reduce colours, drop frames.

Are my GIFs uploaded to a server when I use an online resizer?

It depends on the tool’s architecture. Server-side tools upload and return the file; client-side tools run everything in the browser. Client-side tools use WebAssembly builds such as gifsicle, so the file never leaves your device. Test by disconnecting the network mid-resize — local processing still completes.

2026年10月9日

HTML to JPG (html-to-jpg): Complete Conversion Guide

To convert HTML to JPG (html-to-jpg), upload your file or enter a URL into a free online converter such as CoolUtils or Aspose. The tool renders the page and saves it as a JPG snapshot. For batch or automated work, desktop tools or command-line APIs are the better path.

How to Convert HTML to JPG: Step-by-Step

The fastest way is to use a browser-based converter. You upload an HTML file or paste a URL, pick JPG as the output format, and download the rendered image. Most free tools work this way, though file size limits, quality controls, and deletion policies vary.

Using an Online Converter (CoolUtils or Aspose)

CoolUtils and Aspose both offer free online HTML to JPG converters that run right in the browser. No installation is needed.

CoolUtils workflow

Open the CoolUtils online HTML to JPG page.
Upload an HTML, HTM, XHTML, MHTML, or MHT file. The converter accepts files up to 50 MB.
Choose JPG or JPEG in the output format list.
Add optional header or footer text if you need it.
Click Download Converted File to save the JPG snapshot.

According to CoolUtils, the service processes uploads over HTTPS/TLS and automatically deletes both input and output files after conversion. The same page reports that CoolUtils has converted 157,328,305 files totaling 4,801 TB.

Aspose workflow

Open the free Aspose HTML to JPG converter.
Click the file drop area to upload or drag and drop an HTML file. You can also enter a URL.
Click Convert to render the page as a JPG.
Download the result from the link that appears.

Aspose’s free tier is more limited. According to Aspose, free users can process 5 files per day, with a 5 MB total size limit and 2 operations daily. Files are automatically deleted from Aspose servers after 24 hours.

Converting Multiple Files with a Desktop Tool

Online converters get frustrating once you have many HTML files. Desktop software like Total HTML Converter can process entire folders in a single run and keeps everything on your local machine.

The basic desktop workflow is:

Add a folder of HTML, HTM, or MHT files.
Select JPG as the output format.
Set JPEG quality and output dimensions if needed.
Run the batch conversion, then grab the JPG files from the output folder.

CoolUtils says Total HTML Converter can convert hundreds of files in three clicks, works offline, and includes batch conversion, JavaScript toggles, CSS rendering, and JPEG quality control.

HTML to JPG Conversion Methods Compared

There are five practical ways to convert HTML to JPG: online converters, desktop software, command-line tools, APIs, and headless browsers. They differ in privacy, batch capability, file size limits, and how well they fit automation. The right choice depends on how many files you handle, where the files live, and whether the workflow must run unattended.

Online Converters: Free, Fast, and Limited

Online HTML to JPG converters work well for one-off conversions and quick previews. You don’t need to install anything, and they work from any device with a browser.

The main trade-offs are file size limits and privacy. CoolUtils accepts files up to 50 MB and automatically deletes input and output files after conversion, according to CoolUtils. Aspose is stricter: free accounts can handle 5 files, 5 MB total size, and 2 operations per day, with files deleted after 24 hours, according to Aspose.

Online tools also tend to process one file at a time. CoolUtils notes that its online MHTML to JPG converter handles a single file at a time, while batch conversion requires the desktop version. If you only need occasional snapshots or want to test a workflow, an online converter is the easiest place to start.

Desktop Software: Batch Processing and Total HTML Converter

Desktop software removes the file size, privacy, and volume limits that come with online tools. CoolUtils sells Total HTML Converter as the desktop option, with a one-time price of $59.90 for a lifetime license and commercial use.

Key capabilities include:

Batch conversion of HTML, HTM, MHT, and XHTML files
Full CSS rendering with controls to enable or disable JavaScript
Fit-to-page layout for consistent output
Adjustable JPEG quality to balance file size and image fidelity
Output to JPG, PNG, TIFF, PDF, DOC, XLS, and other formats
Watermark, page counter, and date options for output files
Command-line execution and an SDK for integration

Desktop conversion keeps files on your own machine, which matters for sensitive documents. It also removes the 50 MB online file limit: if an HTML file or web archive exceeds 50 MB, the desktop tool can still process it.

Command-Line Tools and APIs for Automation

Automated workflows need a path that runs without manual uploads or clicking through a GUI. The two main options are local command-line converters and cloud APIs.

Total HTML Converter X is CoolUtils’ server-oriented command-line tool. It converts HTML files and live URLs to JPG from cmd.exe or PowerShell using HTMLConverter.exe. A basic batch command looks like this:

HTMLConverter.exe C:\Pages\*.html C:\Output\ -c JPEG -ImgQuality 90 -ImgWidth 1024

This renders every HTML file in the source folder to a JPG with the same base name. Flags such as -ImgQuality, -ImgWidth, and -combine control JPEG quality, output dimensions, and full-page rendering. The tool can run from a .bat file, Windows Task Scheduler, or an ActiveX/COM interface from .NET, PHP, Python, and other environments.

For cloud-based integration, HTML/CSS to Image offers an API that returns PNG, JPG, WebP, or PDF output from HTML/CSS, URLs, or reusable templates. The documentation says the service has generated more than 100 million images and has been in production since 2018. Companies including Uber, HubSpot, Airtable, monday.com, Yamaha, Wayfair, PlanetScale, Expensify, and Coldwell Banker use it.

Headless browsers like Puppeteer or Playwright can also render HTML to JPG, but they bring maintenance and resource overhead. Marek Dvorak, Senior Backend Engineer, puts it this way: “We replaced a Puppeteer-based screenshot pipeline with Total HTML Converter X about a year ago. The Puppeteer setup needed constant babysitting after Chrome updates and consumed ~400 MB of RAM per worker. The CoolUtils command line takes a fraction of the resources, never breaks on updates, and produces consistent JPG output. We render about 40,000 product pages a night without a single failure.”

For compliance snapshots, Janelle Foster, Compliance Manager, describes a scripted approach: “I wrote a small .bat script that pulls a list of URLs from a CSV and runs HTMLConverter.exe against each one, naming the output JPGs with the date. It runs on a Windows Server 2019 box, uses a few percent of CPU, and produces clean, identical-looking screenshots regardless of when the script runs.”

JPEG Quality Settings and Output Control

JPG is a lossy format, so the quality setting controls how much compression gets applied. That directly affects file size and visual fidelity. Lower values create smaller files but can introduce visible artifacts; higher values preserve more detail but produce larger files.

CoolUtils recommends values between 85 and 92 as the sweet spot for web use. In Total HTML Converter X, the -ImgQuality flag accepts any value from 1 to 100. The -ImgWidth and -ImgHeight flags set output dimensions in pixels, and -combine renders the whole document as one tall JPG instead of splitting it into pages.

Desktop Total HTML Converter also exposes JPEG quality as a user-facing option. CoolUtils notes that when converting HTML to JPEG, users can “set the desired quality of the JPEG image to compromise the file size.” Online converters usually offer fixed or limited quality settings, so if you need precise control over output size and sharpness, a desktop or command-line tool is the more reliable route.

Method selection at a glance

Use case	Recommended path
One-off conversion or quick preview	Free online converter such as CoolUtils or Aspose
Batch conversion of local files	Desktop Total HTML Converter
Sensitive or legal documents	Desktop or command-line tool that keeps files local
Automated server pipeline without a browser	Total HTML Converter X command line
Cloud-based integration or template-driven generation	HTML/CSS to Image API
JavaScript-heavy single-page apps	Headless browser or Chrome-rendering API

HTML, HTM, MHTML, MHT: What’s the Difference?

HTML to JPG conversion often involves several related file extensions. The input type affects which tool can handle the file and how the rendered output looks.

HTML vs HTM: Same Language, Different Extension

HTML and HTM are the same markup language. The .htm extension is the older three-character form that came from the DOS 8.3 filename limit, which allowed only three characters after the dot. Modern systems treat .htm and .html files the same way, and browsers open both natively.

CoolUtils describes HTM as “functionally identical to HTML” and notes that the .htm extension is often used for compatibility with legacy systems and older operating systems. When you convert to JPG, choosing HTML or HTM makes no difference to the process or the result.

MHT vs MHTML: One Archive Format, Two Extensions

MHT and MHTML are also the same format, but they are not the same thing as a plain HTML page. MHTML, short for MIME HTML, is defined by RFC 2557. It bundles a complete web page into a single file using MIME multipart encoding, combining HTML markup, CSS, JavaScript, and embedded images.

The only difference between MHT and MHTML is the extension. .mht is the older three-character form used by Internet Explorer, while .mhtml is the longer, modern form used by Edge and some browser extensions. CoolUtils states that both extensions implement RFC 2557 MIME encapsulation and that its converter processes them identically.

Browser Support and Security Implications

MHTML support has shrunk in modern browsers. According to CoolUtils, Chrome removed native MHTML support in 2020 and Firefox removed it in 2021, both citing security vulnerabilities. The worry is that MHTML files can embed active scripts that execute in privileged contexts, creating an attack vector for malicious .mht or .mhtml attachments.

Edge still supports MHT natively, but on many non-Windows systems the files cannot be opened reliably. Converting MHTML or MHT to JPG sidesteps the compatibility issue entirely: you get a static image that requires no browser or archive viewer.

When choosing an input type, use HTML or HTM if you have raw markup or a saved page in plain markup form. Use MHTML or MHT if the file was saved as a web archive from Internet Explorer, Edge, or a browser extension, because those files include embedded resources that an ordinary HTML file may reference externally.

Full-Page vs Viewport Capture: What Gets Captured?

Capture behavior varies by tool and sometimes by input type. Some converters capture only the visible viewport, while others render the full page height from top to bottom.

The difference matters for long pages. A viewport-only capture shows only the part visible without scrolling, so content below the fold can get cut off. A full-page capture stitches the entire document height into a single JPG, which works better for archived articles, complete receipts, and legal notices.

CoolUtils illustrates both behaviors on its own pages. For MHTML and MHT online conversion, CoolUtils says the converter renders the complete document from top to bottom and captures the entire page height as a single JPG. For HTM online conversion, though, CoolUtils says the online converter captures the initial viewport area at a standard desktop viewport width, while the desktop Total HTML Converter offers a full-page rendering mode.

So don’t assume every “HTML to JPG” tool behaves the same way. Before converting a long page, check for a “full-page,” “entire page,” or “combine” option. If the online converter only captures the viewport, use a desktop or command-line tool instead.

Output resolution also depends on the rendering engine and viewport width. CoolUtils notes that its online HTM converter renders at a 1280-pixel viewport width at screen resolution, while the desktop version lets you set custom viewport width and DPI for higher-resolution output.

JavaScript Rendering and Dynamic Web Pages

Many lightweight HTML to JPG converters do not execute JavaScript. If a page loads content dynamically through scripts, that content may be missing from the resulting JPG. CoolUtils states plainly for its online MHTML converter that “dynamic JavaScript is not executed; the page is captured in its loaded state.”

You’ll notice this limitation most with single-page applications and other JavaScript-heavy sites. A renderer that stops after loading the initial HTML will capture placeholders, empty containers, or loading spinners instead of the final rendered content.

For such pages, you have three options:

Use a headless browser like Puppeteer or Playwright, which executes JavaScript and renders the page the way a real browser would.
Use an API that renders in a browser engine. The HTML/CSS to Image API documentation notes that its service renders HTML/CSS in Google Chrome, which means JavaScript can run before capture.
Use a converter with a JavaScript enable/disable option, such as CoolUtils Total HTML Converter, which lets users enable or disable JavaScript and stop slow scripts.

The trade-off is resource and maintenance cost. Headless browsers give the most faithful rendering but require careful sandboxing and can break after browser updates. As Marek Dvorak, Senior Backend Engineer, put it, a Puppeteer-based pipeline “needed constant babysitting after Chrome updates and consumed ~400 MB of RAM per worker,” which led his team to replace it with Total HTML Converter X for 40,000 nightly renders.

Which Tools Execute JavaScript?

Not all converters execute JavaScript, and this isn’t always obvious from a product page. In general:

Lightweight online converters often render the page in its loaded state without running dynamic scripts.
Desktop CoolUtils Total HTML Converter offers an option to enable or disable JavaScript and can stop slow scripts.
The HTML/CSS to Image API renders in Google Chrome, so JavaScript can be part of the capture.
Headless browser automation such as Puppeteer or Playwright executes JavaScript by default.

If your page needs JavaScript to display visible content, check the tool’s rendering engine before relying on the output.

Privacy and Security: What Happens to Your Files?

Online converters require uploading files to a third-party server, which raises privacy considerations no matter what security claims the provider makes.

CoolUtils describes its online conversion as encrypted in transit with HTTPS/TLS and processed in data centers with multi-factor access control. It also says both input and output files are deleted automatically from its servers after conversion, and that files are never read, shared, or repurposed. Aspose states that uploaded files are automatically deleted after 24 hours and that users can delete them immediately.

Even with these policies, online conversion isn’t right for every document. For sensitive legal, compliance, or internal business content, local processing is safer. Desktop software like Total HTML Converter and command-line tools like Total HTML Converter X keep files on the local machine. CoolUtils emphasizes this point in its desktop comparison: files “never leave your machine.”

File size limits also overlap with privacy and workability. CoolUtils online supports files up to 50 MB, while Aspose free users are limited to 5 MB total and 2 operations per day. Files that exceed online limits must be converted locally, which is often the better privacy choice anyway.

Use Cases: Who Needs HTML to JPG Conversion?

HTML to JPG conversion serves several different groups, each with its own needs for volume, privacy, and automation.

Casual users need quick, one-off conversions for sharing or embedding. A free online converter like CoolUtils or Aspose is usually enough, with no installation or signup required.

Compliance and legal teams need archived snapshots with timestamps and consistent rendering. Janelle Foster, Compliance Manager, uses a .bat script to pull URLs from a CSV and run HTMLConverter.exe against each one, naming the output JPGs with the date. The script runs on a local Windows server and produces “clean, identical-looking screenshots regardless of when the script runs.”

E-commerce and development teams often need batch product page rendering or CMS thumbnail generation. The same command-line approach can run nightly over a catalog. Marek Dvorak’s team renders about 40,000 product pages a night with Total HTML Converter X after moving away from Puppeteer.

Students, researchers, and content creators usually want to save web content as images for presentations or documentation. CoolUtils user reviews describe converting market research pages into visual summaries, archiving competitor product pages as a visual timeline for PowerPoint reports, and generating JPG screenshots for legal documents without needing technical viewers.

Across these use cases, the pattern stays the same: online converters handle occasional needs, while batch, legal, and production workflows benefit from desktop or command-line tools that keep files local and run without manual interaction.

Conclusion

HTML to JPG conversion can be as simple as uploading a file to a free online converter, but the right method depends on volume, privacy needs, and automation requirements. For one-off tasks, start with CoolUtils or Aspose and download the rendered snapshot in seconds. For batch jobs, sensitive files, or unattended workflows, choose a desktop tool like Total HTML Converter or a command-line solution like Total HTML Converter X. Matching the tool to the use case helps you avoid file-size limits, privacy exposure, and manual overhead.

FAQ

What is the difference between MHT and MHTML files?

MHT and MHTML are the same web archive format. The only difference is the file extension: .mht is the older three-character form from DOS 8.3 filename limits, while .mhtml is the modern four-character extension. Both implement RFC 2557 MIME encapsulation of HTML, and converters process them identically.

Why can’t Chrome open MHTML or MHT files?

Chrome removed native MHTML support in 2020–2021 because of security vulnerabilities tied to embedded active scripts. Firefox also removed support in 2021. Edge still opens MHT natively. To view the content without a compatible browser, convert the MHTML or MHT file to HTML or JPG.

Will the JPG capture the full page or just the visible viewport area?

It depends on the tool’s settings. Some converters capture only the visible viewport, while others render the full page height. Before converting a long page, check for a “full-page,” “entire page,” or “combine” option, or use a desktop tool with full-page rendering.

Can I batch convert multiple HTML files to JPG in one run?

Yes. Desktop tools like CoolUtils Total HTML Converter support batch processing and can convert entire folders in a single run. Online converters typically handle one file at a time or impose strict daily limits, so they aren’t practical for large batch jobs.

Is online HTML to JPG conversion safe for sensitive or legal documents?

Online tools upload files to third-party servers, which creates privacy risk even when deletion policies exist. For sensitive documents, use a desktop tool or command-line script that keeps files local. CoolUtils and Aspose both publish deletion policies, but sensitive work is safer offline.

What resolution and JPEG quality should I expect from the output?

Output resolution depends on the rendering engine and the page’s dimensions. JPEG quality is often adjustable from 1 to 100; 85–92 is the typical sweet spot for web use. Higher values preserve more detail but create larger files.

2026年10月9日