Developer tools · Chmod calculator
chmod symbolic mode explained: u+x, g-w, o=r and a+rX
· How it works
chmod unix developer-workflow
The symbolic form of chmod is a tiny grammar: who, operator, which bits. This post takes it apart so u+x and go-rwx become obvious, and shows when symbolic beats octal.
A deploy script full of letters — chmod u+x,go-w deploy.sh works, but nobody on the team can say what it changes
A command such as u+x looks like the calculator's symbolic display, but the two forms have different jobs. The editable symbolic field accepts nine permission positions, optionally preceded by a recognized file-type character. By contrast, the generated chmod argument spells out complete assignments with u=, g=, and o= clauses, so it represents a fixed mode rather than parsing a relative change.
Entering 750 makes the distinction concrete. The display is rwxr-x---, while the generated assignment is u=rwx,g=rx,o=. Both describe the same owner, group, and other bits, yet only the second is formatted as a chmod argument. The page never runs that command. It exposes the representation so the proposed value can be reviewed before any separate shell action.
The calculator separates an ls-style display from the assignment list it generates
The letters u, g, and o appear in the generated assignment because they label owner, group, and other. Every output names all three classes explicitly, including an empty clause when a class has no permissions. The calculator does not parse omitted-who grammar or an a shorthand. Its input starts from a completed mode, not instructions whose result depends on an existing target.
This correction prevents a subtle overclaim. The matrix can show exactly which class receives read, write, or execute, but it cannot decide what an omitted class selector would mean in another chmod implementation. Compare the three matrix columns with the three assignment clauses instead. Their agreement verifies the fixed value without relying on relative-command rules that this interface does not implement.
Who letters appear in generated assignments; relative omitted-who grammar is not parsed
The assignment generator uses = for each ordinary class. That choice rebuilds the requested owner, group, and other triples exactly, including clearing a class by emitting an empty right-hand side. Although + and - belong to symbolic chmod commands, they are not accepted as calculator input. The page therefore does not model incremental additions or removals from an unknown starting mode.
A one-bit comparison shows what the supported workflow can prove. Mode 750 renders rwxr-x---; changing the group digit to 7 produces rwxrwx--- and changes g=rx to g=rwx. The calculator identifies the completed before-and-after modes. It does not evaluate g+w against a live file, because no current mode, path, filesystem, or command execution participates in the conversion.
The generated operator is =, while + and - input grammar remains outside the tool
The parser recognizes r and w in their fixed positions, plus x or - in ordinary execute positions. It also accepts s, S, t, and T where special bits share those positions. Capital X is different: it belongs to relative chmod grammar and is not supported here. Supplying X is rejected rather than silently interpreted as an ordinary execute bit.
Lowercase and uppercase special letters are implemented deliberately. Setuid and setgid use s when their matching execute bit is present and S when it is absent; sticky uses t or T by the same rule in the other-execute position. The special row and four-digit summary preserve those bits. None of this adds support for conditional capital-X selection across files and directories.
The parser accepts r, w, x, s, S, t and T; capital X is not supported
Class-copy expressions such as g=u are not implemented. The calculator never reads a source class from an existing object or applies one class's bits to another. It receives a complete octal or ls-style mode, converts that value into named booleans, and emits explicit flags for each class. Any copied result must be calculated elsewhere before this page can inspect it.
Suppose an external step determines that owner and group should both have rwx while other has none. Entering 770 yields rwxrwx--- and u=rwx,g=rwx,o=. That confirms the completed result but does not prove how it was derived. Ownership also remains unknown: the converter labels classes without identifying the real owner, group, or process that would encounter the target.
Copying permissions between classes is not implemented
Mode 0750 is accepted with its leading zero and parsed as the same value as 750. Owner digit 7 activates read, write, and execute; group digit 5 activates read and execute; other digit 0 activates nothing. The synchronized display becomes rwxr-x---, and the always-four-digit summary keeps 0750 visible as an unambiguous review value.
The generated symbolic assignment for that fixed mode is u=rwx,g=rx,o=. Its three clauses correspond directly to the matrix columns, while the octal command preview uses 750 unless a special bit requires a fourth digit. A supplied path may be quoted in the preview, but it is never opened. The example verifies representation, not ownership, authorization, or a successful permission change.
Worked example: 0750 as a fixed mode and generated assignment list
Reference-based changes, symlink handling, and ACL operations remain outside this converter. There is no reference-file input, path traversal, ACL entry model, or filesystem query in the page. Selecting recursion only adds a displayed -R flag. Consequently, the generated command cannot report which objects would be reached or whether another access-control layer changes the effective outcome.
Invalid input provides a useful boundary check. A misplaced permission letter, unsupported X, trailing marker, or malformed octal digit is rejected instead of repaired. Correcting the text to a supported nine-character display produces a mode and synchronized views. That acceptance proves only that the string maps to the implemented twelve bits; it does not validate an external chmod feature or target environment.
Reference, symlink and ACL operations remain outside this converter
The practical distinction is between an ls-style display and a generated fixed assignment, not between symbolic input as relative and octal input as absolute. Both editable forms represent a completed mode. The calculator converts either one into the same integer, matrix, summary, explanation, and previews, then emits explicit u=, g=, and o= clauses for the symbolic command form.
Use those synchronized views to catch arithmetic mistakes. If 750, rwxr-x---, and u=rwx,g=rx,o= appear together, the fixed mode is internally consistent. Stop there unless the actual system supplies more evidence. The page does not parse relative operators, omitted selectors, class copying, or capital X, and it cannot determine whether the mode addresses the real failed operation.