Carry is the opposite of borrow. It occurs when breaking through the upper bound of modulo arithmetic.

In computer science: when adding one unsigned register to a similar-sized unsigned register, a carry occurs when the result is too large to represent in the same number of bits. A carry flag is set when this occurs - it is cleared when an addition does not have this result. The carry flag is useful for multiple-word aritmetic: given a 2-word value `AB` (register `A` holding the most significant word, register `B` being the least significant word), to add a 1-word value `C`: First add `C` to `B`. If this causes a carry, increment `A`. If the increment causes a carry also, then the overall result is too large even for a 2-word representation, otherwise the result is correctly stored in `AB`.

Because of this, many machine code instruction sets include not only an 'add' instruction, but also an 'add with carry' instruction. To add a pair of 3-word values `ABC` and `DEF`, then, the pseudocode would look something like:

```
clear the carry flag
```

add with carry, F to C

add with carry, E to B

add with carry, D to A

(The first two instructions could be replaced with a single regular 'add' instruction... the verbosity is intentional, to illustrate the pattern that is at work here.) If the carry is set after all that, the result is too big for `ABC`.

Also called unsigned overflow.