The Chmod Calculator converts any complete Unix permission snapshot between a strict octal value (such as 755 or 4755) and a canonical nine-character symbolic string (such as rwxr-xr-x), handling the full setuid, setgid, and sticky state in the browser tab. Every value is validated against POSIX position rules before a result is shown, so each conversion is safe to repeat across hundreds of permission patterns without uploading anything. That makes it practical to bulk-review mode bits: paste one octal or symbolic snapshot, read the canonical octal, the nine-character form, and the owner/group/others table, then change the input to process the next entry. Because the entire 12-bit range — 4,096 distinct modes from 0000 to 7777 — is covered, no value in the standard chmod space is left out of reach. Special bits combine into the leading digit the same way they always have on Unix: setuid is 4, setgid is 2, sticky is 1, and the three add together to define the mode's wider behaviour. The visible output is meant to be reviewed, not just trusted, so any pasted command template should be cross-checked against the actual target, the owner, and the principle of least privilege before it is applied to a live system.
How strict input validation makes bulk review safe
"Bulk" with this calculator does not mean pasting a CSV of values and getting a CSV of results. It means moving through many permission snapshots quickly, one after another, inside a single tab. That workflow only holds up if the tool refuses every malformed input and refuses to carry a stale result forward when the input changes. The Chmod Calculator enforces a small, strict contract on both sides of the conversion:
- Octal input must be exactly three ordinary digits (for example 755) or four digits when special bits apply (for example 4755). The leading zero in 0755 is accepted but canonical output drops it.
- Symbolic input must be exactly nine characters: three for owner, three for group, three for others. The leading file-type dash used by ls -l and chmod modification expressions like u+x are both rejected rather than guessed.
- The raw input field is bounded at 32 UTF-16 code units. The final character that fits shows a syntax error; the character that would push past the limit shows an explicit budget error. Nothing is silently truncated.
Editing the input clears the previous result, error, and copy state immediately. A late asynchronous clipboard result cannot publish a stale success after the mode changes. For a bulk-review workflow, this means each new entry starts from a clean slate and you cannot end up applying the wrong chmod template because an old conversion lingered on the screen.
If you are pulling permission strings from a real file or directory, the companion guide on finding and converting a file's chmod value shows the matching round-trip from stat output back into a validated mode string before you hand it to the calculator.
Convert a batch of chmod values with the browser tool
Once the validation rules are clear, processing many permission values is just a matter of repeating the same short procedure for each one:
- Open the Chmod Calculator and choose octal-to-symbolic or symbolic-to-octal. Switching the direction loads an appropriate example and clears any earlier output.
- Type or paste the first complete snapshot in the strict form required — three or four ASCII octal digits, or a nine-character symbolic string.
- Read the canonical octal, the nine-character symbolic value, and the owner/group/others table side by side. Cross-check the bits in the table against what you expect for owner, group, and others.
- Confirm any setuid (s/S), setgid (s/S), or sticky (t/T) mark in the symbolic output matches the leading digit in canonical octal.
- Use Copy to write a chmod OCTAL FILE template to the clipboard. Replace the FILE placeholder with the real path only after reviewing ownership, parent-directory traversal, and least-privilege needs.
- Edit the input field to load the next value. The previous result, error, and copy status are cleared automatically.
This six-step loop is the bulk conversion pattern. With keyboard focus on the input field, it usually runs faster than reaching for a desktop calculator or a printed cheat sheet, and every reviewable piece of information — octal, symbolic, and the table — stays visible at once.
Reading ordinary and special octal digits
The three ordinary octal positions correspond to owner, group, and others. Each position is built by adding read (4), write (2), and execute or directory search (1). The full set of digit values is small and worth memorising, because it is what every chmod command and every listing tool uses.
| Digit | Read (4) | Write (2) | Execute (1) | Meaning |
|---|---|---|---|---|
| 0 | — | — | — | No ordinary permissions |
| 1 | — | — | on | Execute or directory search only |
| 2 | — | on | — | Write only |
| 3 | — | on | on | Write and execute |
| 4 | on | — | — | Read only |
| 5 | on | — | on | Read and execute |
| 6 | on | on | — | Read and write |
| 7 | on | on | on | Read, write, and execute |
When a fourth digit appears, it is not part of the owner, group, or others positions. It combines the three special bits: setuid is 4, setgid is 2, sticky is 1. So 6755 carries setuid and setgid together, 7755 carries all three special bits, and 4755 is a classic setuid executable mode. Canonical output keeps a nonzero leading digit and drops a redundant leading zero when no special bit is set; 0755 round-trips to the same 755 you would type by hand.
Symbolic snapshots and the s, S, t, T case rule
The nine-character symbolic form is three triples: rwx for owner, rwx for group, rwx for others. Read positions accept r or a hyphen, write positions accept w or a hyphen, and ordinary execute positions accept x or a hyphen. This is the permission portion commonly shown by listing tools, minus the leading file-type character.
Special bits share the three execute positions, and the calculator preserves the case distinction that ls uses so a round-trip can recover the exact bits. The rule is short and worth keeping in mind for bulk review work:
- Lowercase s in the owner or group execute slot means the matching special bit (setuid or setgid) is set AND the execute bit is also set.
- Uppercase S means the special bit is set but execute is absent — the special bit has nothing to apply to.
- Lowercase t in the others execute slot means the sticky bit is set AND others execute is present.
- Uppercase T means sticky is set but others execute is absent.
Because the case survives every conversion, looking at whether you see rws, rwS, rwt, or rwT tells you immediately whether the relevant execute bit is also present. Anything that folds case, strips case, or renders the special bits as plain x loses that information and breaks a true mode-bit round-trip.
What the bulk converter does not do
There is a clear line between what the calculator describes and what it actually changes. For bulk workflows in particular, the limits matter because they shape what you still have to do by hand outside the browser tab:
- It does not run chmod on any file, local or remote. It only converts text in the browser and copies a chmod OCTAL FILE template. The FILE slot is a literal placeholder.
- It does not accept a file path, current permissions, ownership, or umask. Umask is not a fourth digit silently applied to your input.
- It does not parse chmod modification expressions like u+x, nor the leading file-type dash from ls -l output. These carry different information and would be guessed, so they are rejected.
- It does not recurse into directories, follow symbolic links, or touch ACLs, capabilities, or filesystem flags such as read-only or noexec.
- It does not determine whether a requested mode is actually safe for a particular service. A value of 777 may still fail because of an ACL, parent-directory traversal, or mount state.
In other words, the output is a review aid for requested mode bits, not a guarantee of effective authorisation. POSIX defines the bit positions, but access can still be affected by ownership, access control lists, capabilities, mount options, read-only filesystems, application sandboxing, and other operating-system policy, as documented in the GNU chmod manual page. A process also needs permission to traverse parent directories, and a 777 mode does not waive that requirement.
Practical tips for a bulk pass over permission values
A few small habits keep a long batch review reliable. Keep the input field focused and the conversion direction locked for the whole pass so a stray Tab does not flip the example on you. Cross-check at least one octal and one symbolic value against a known reference (such as 700 versus rwx------) early in the session to confirm the direction is reading what you expect. Where the table and the symbolic output appear to disagree, trust the table — canonical octal, the symbolic form, and the table are derived from the same bit pattern, but the table shows owner, group, and others one column at a time, which is usually easier to spot-check for a long run of values.
Finally, avoid copying broad examples such as 777 across a long list of files simply to bypass a permission error. Diagnose ownership, groups, parent-directory traversal, ACLs, and service identity first; the bulk step is the review, not the fix. The calculator gives you the mode bits the command will request; the operating system decides which of those bits survive, and that is a separate question for the host.